@Override protected void configure() { install(new CollectorControllerMBeanModule()); } }
HttpSender(final ThreadSafeAsyncHttpClient client, final long httpMaxWaitTimeInMillis, final Timer sendTimer, final int httpWorkersPoolSize) { this.client = client; this.httpMaxWaitTimeInMillis = httpMaxWaitTimeInMillis; this.sendTimer = sendTimer; this.workers = new LocalQueueAndWorkers(httpWorkersPoolSize); }
@Override public void handle(final File file, final CallbackHandler handler) { eventSender.send(file, handler); } }, config.getSpoolDirectoryName(), config.isFlushEnabled(), config.getFlushIntervalInSeconds(), executor,
@Override protected void configure() { super.configure(); switch (eventTrackerConfig.getType()) { case COLLECTOR: final EventSender httpSender = new HttpSender( eventTrackerConfig.getCollectorHost(), eventTrackerConfig.getCollectorPort(), eventTrackerConfig.getEventType(), eventTrackerConfig.getHttpMaxWaitTimeInMillis(), eventTrackerConfig.getHttpMaxKeepAlive().getMillis(), eventTrackerConfig.getHttpWorkersPoolSize() ); bind(EventSender.class).toInstance(httpSender); log.info("Enabled HTTP Event Logging"); break; case NO_LOGGING: bind(EventSender.class).to(NoLoggingSender.class).asEagerSingleton(); log.info("Disabled Event Logging"); break; default: throw new IllegalStateException("Unknown type " + eventTrackerConfig.getType()); } } }
@Override protected void configure() { super.configure(); switch (eventTrackerConfig.getEventType()) { case SMILE: bind(EventSerializer.class).toInstance(new SmileEnvelopeEventSerializer(false)); break; case JSON: bind(EventSerializer.class).toInstance(new SmileEnvelopeEventSerializer(true)); break; default: bind(EventSerializer.class).to(ObjectOutputEventSerializer.class); break; } } }
public void close() { setAcceptEvents(false); try { commit(); flush(); eventWriter.close(); } catch (IOException e) { log.warn("Got I/O exception closing the eventtracker library: " + e); } }
singletonController = new HttpCollectorFactory( collectorHost, collectorPort, maxUncommittedPeriodInSeconds, httpWorkersPoolSize ).get();
@Inject public ThresholdEventWriterProvider(final DiskSpoolEventWriter eventWriter, final EventTrackerConfig config) { this.eventWriter = eventWriter; this.maxUncommittedWriteCount = config.getMaxUncommittedWriteCount(); this.maxUncommittedPeriodInSeconds = config.getMaxUncommittedPeriodInSeconds(); }
@Override public CollectorController get() { final CollectorController controller = new CollectorController(eventWriter); // Make sure to flush all files on shutdown Runtime.getRuntime().addShutdownHook(new Thread() { @Override public void run() { mainEventTrackerShutdownHook(eventSender, controller); } }); return controller; }
private void installEventtracker() { if (!trackRequests) { return; } install(new CollectorControllerSmileModule()); install(new CollectorControllerHttpMBeanModule()); bind(Tracker.class).to(CollectorTracker.class).asEagerSingleton(); filter("*").through(TrackerFilter.class); }
@Override public void run() { mainEventTrackerShutdownHook(eventSender, controller); } });
public void submitRequest() { client.executeRequest(file, completionHandler); } }
public static void shutdown() { eventSender.close(); } }
@Override public void handle(final File file, final CallbackHandler handler) { eventSender.send(file, handler); } }, spoolDirectoryName, isFlushEnabled, flushIntervalInSeconds, new FailsafeScheduledExecutor(1, "EventtrackerFlusher"),
public final boolean isExpired() { return isExpired(System.currentTimeMillis()); }
public void run() { while (true) { try { final HttpJob job = jobQueue.take(); job.submitRequest(); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); return; } } } }
public LocalQueueAndWorkers(final int senderCount) { this.executor = new FailsafeScheduledExecutor(senderCount, "http-SenderWorkers"); for (int idx = 0; idx < senderCount; idx++) { executor.submit(new SenderWorker(queue)); } }
public HttpSender(final String collectorHost, final int collectorPort, final EventType eventType, final long httpMaxWaitTimeInMillis, final long httpMaxKeepAliveInMillis, final int httpWorkersPoolSize) { this(new ThreadSafeAsyncHttpClient(collectorHost, collectorPort, eventType, httpMaxKeepAliveInMillis), httpMaxWaitTimeInMillis, Metrics.newTimer(HttpSender.class, collectorHost.replace(":", "_"), TimeUnit.MILLISECONDS, TimeUnit.SECONDS), httpWorkersPoolSize); }
public ThreadSafeAsyncHttpClient(final String collectorHost, final int collectorPort, final EventType eventType, final long httpMaxKeepAliveInMillis) { this.collectorURI = String.format("http://%s:%d%s", collectorHost, collectorPort, URI_PATH); this.eventType = eventType; this.httpConnectionExpiration = new ExpirationTimer(httpMaxKeepAliveInMillis); // CAUTION: it is not enforced that the actual event encoding type on the wire matches what the config says it is // the event encoding type is determined by the Event's writeExternal() method. this.clientConfig = new AsyncHttpClientConfig.Builder() .setIdleConnectionInPoolTimeoutInMs(DEFAULT_IDLE_CONNECTION_IN_POOL_TIMEOUT_IN_MS) .setConnectionTimeoutInMs(100) .setMaximumConnectionsPerHost(-1) // unlimited connections .build(); }