public StreamOpStats(StatsLogger statsLogger, StatsLogger perStreamStatsLogger) { this.baseStatsLogger = statsLogger; this.requestStatsLogger = statsLogger.scope("request"); this.recordsStatsLogger = statsLogger.scope("records"); this.requestDeniedStatsLogger = statsLogger.scope("denied"); this.streamStatsLogger = perStreamStatsLogger; }
public StatsLogger requestScope(String scopeName) { return requestStatsLogger.scope(scopeName); }
public StatsLogger streamRequestStatsLogger(String streamName) { return streamStatsLogger.scope(streamName); }
protected static StatsLogger requestLogger(StatsLogger statsLogger) { return statsLogger.scope("request"); }
public StatsLogger baseScope(String opName) { return baseStatsLogger.scope(opName); }
public ZKSessionLockFactory(ZooKeeperClient zkc, String clientId, OrderedScheduler lockStateExecutor, int lockCreationRetries, long lockOpTimeout, long zkRetryBackoffMs, StatsLogger statsLogger) { this.zkc = zkc; this.clientId = clientId; this.lockStateExecutor = lockStateExecutor; this.lockCreationRetries = lockCreationRetries; this.lockOpTimeout = lockOpTimeout; this.zkRetryBackoffMs = zkRetryBackoffMs; this.lockStatsLogger = statsLogger.scope("lock"); }
StreamReader(int idx, StatsLogger statsLogger) { this.streamIdx = idx; int streamId = startStreamId + streamIdx; streamName = String.format("%s_%d", streamPrefix, streamId); statsLogger.scope(streamName).registerGauge("sequence_id", this); }
public BKExceptionStatsLogger getBKExceptionStatsLogger(String phase) { // initialize the parent exception stats logger lazily if (null == parentExceptionStatsLogger) { parentExceptionStatsLogger = statsLogger.scope("exceptions"); } BKExceptionStatsLogger exceptionStatsLogger = exceptionStatsLoggers.get(phase); if (null == exceptionStatsLogger) { exceptionStatsLogger = new BKExceptionStatsLogger(parentExceptionStatsLogger.scope(phase)); BKExceptionStatsLogger oldExceptionStatsLogger = exceptionStatsLoggers.putIfAbsent(phase, exceptionStatsLogger); if (null != oldExceptionStatsLogger) { exceptionStatsLogger = oldExceptionStatsLogger; } } return exceptionStatsLogger; } }
protected static StatsLogger requestScope(StatsLogger statsLogger, String scope) { return requestLogger(statsLogger).scope(scope); } }
private void initializeFuturePool(boolean ordered) { // ownExecutor is a single threaded thread pool if (null == readerFuturePool) { readerFuturePool = buildFuturePool( scheduler, statsLogger.scope("reader_future_pool")); } }
public StatsLogger streamRequestScope(String streamName, String scopeName) { return streamRequestStatsLogger(streamName).scope(scopeName); }
public LimitedPermitManager(final int concurrency, int period, TimeUnit timeUnit, ScheduledExecutorService executorService, StatsLogger statsLogger) { if (concurrency > 0) { this.semaphore = new Semaphore(concurrency); } else { this.semaphore = null; } this.period = period; this.timeUnit = timeUnit; this.executorService = executorService; statsLogger.scope("permits").registerGauge("outstanding", new Gauge<Number>() { @Override public Number getDefaultValue() { return 0; } @Override public Number getSample() { return null == semaphore ? 0 : concurrency - semaphore.availablePermits(); } }); }
public DynamicRequestLimiter(DynamicDistributedLogConfiguration dynConf, StatsLogger statsLogger, Feature rateLimitDisabledFeature) { final StatsLogger limiterStatsLogger = statsLogger.scope("dynamic"); this.dynConf = dynConf; this.rateLimitDisabledFeature = rateLimitDisabledFeature; this.listener = new ConfigurationListener() { @Override public void configurationChanged(ConfigurationEvent event) { // Note that this method may be called several times if several config options // are changed. The effect is harmless except that we create and discard more // objects than we need to. LOG.debug("Config changed callback invoked with event {} {} {} {}", new Object[] { event.getPropertyName(), event.getPropertyValue(), event.getType(), event.isBeforeUpdate()}); if (!event.isBeforeUpdate()) { limiterStatsLogger.getCounter("config_changed").inc(); LOG.debug("Rebuilding limiter"); limiter = build(); } } }; LOG.debug("Registering config changed callback"); dynConf.addConfigurationListener(listener); }
@Override public DistributedLock applyE() throws IOException { // Unfortunately this has a blocking call which we should not execute on the // ZK completion thread BKLogReadHandler.this.readLock = new ZKDistributedLock( lockStateExecutor, lockFactory, readLockPath, conf.getLockTimeoutMilliSeconds(), statsLogger.scope("read_lock")); LOG.info("acquiring readlock {} at {}", getLockClientId(), readLockPath); return BKLogReadHandler.this.readLock; } };
public ZKDistributedLock( OrderedScheduler lockStateExecutor, SessionLockFactory lockFactory, String lockPath, long lockTimeout, StatsLogger statsLogger) { this.lockStateExecutor = lockStateExecutor; this.lockPath = lockPath; this.lockTimeout = lockTimeout; this.lockFactory = lockFactory; lockStatsLogger = statsLogger.scope("lock"); acquireStats = lockStatsLogger.getOpStatsLogger("acquire"); reacquireStats = lockStatsLogger.getOpStatsLogger("reacquire"); internalTryRetries = lockStatsLogger.getCounter("internalTryRetries"); }
static interface ZooKeeperClientHandler<T> { T handle(ZooKeeperClient zkc) throws IOException; }
ZooKeeperClient(String name, int sessionTimeoutMs, int connectionTimeoutMs, String zooKeeperServers, RetryPolicy retryPolicy, StatsLogger statsLogger, int retryThreadCount, double requestRateLimit, Credentials credentials) { this.name = name; this.sessionTimeoutMs = sessionTimeoutMs; this.zooKeeperServers = zooKeeperServers; this.defaultConnectionTimeoutMs = connectionTimeoutMs; this.retryPolicy = retryPolicy; this.statsLogger = statsLogger; this.retryThreadCount = retryThreadCount; this.requestRateLimit = requestRateLimit; this.credentials = credentials; this.watcherManager = ZKWatcherManager.newBuilder() .name(name) .statsLogger(statsLogger.scope("watcher_manager")) .build(); }
BKAsyncLogWriter(DistributedLogConfiguration conf, DynamicDistributedLogConfiguration dynConf, BKDistributedLogManager bkdlm, BKLogWriteHandler writeHandler, /** log writer owns the handler **/ FeatureProvider featureProvider, StatsLogger dlmStatsLogger) { super(conf, dynConf, bkdlm); this.writeHandler = writeHandler; this.streamFailFast = conf.getFailFastOnStreamNotReady(); this.disableRollOnSegmentError = conf.getDisableRollingOnLogSegmentError(); // features disableLogSegmentRollingFeature = featureProvider.getFeature(CoreFeatureKeys.DISABLE_LOGSEGMENT_ROLLING.name().toLowerCase()); // stats this.statsLogger = dlmStatsLogger.scope("log_writer"); this.writeOpStatsLogger = statsLogger.getOpStatsLogger("write"); this.markEndOfStreamOpStatsLogger = statsLogger.getOpStatsLogger("mark_end_of_stream"); this.bulkWriteOpStatsLogger = statsLogger.getOpStatsLogger("bulk_write"); this.getWriterOpStatsLogger = statsLogger.getOpStatsLogger("get_writer"); this.pendingRequestDispatch = statsLogger.getCounter("pending_request_dispatch"); }