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"); }
public SimplePermitLimiter(boolean darkmode, int permitsMax, StatsLogger statsLogger, boolean singleton, Feature disableWriteLimitFeature) { this.permits = new AtomicInteger(0); this.permitsMax = permitsMax; this.darkmode = darkmode; this.disableWriteLimitFeature = disableWriteLimitFeature; // stats if (singleton) { statsLogger.registerGauge("num_permits", new Gauge<Number>() { @Override public Number getDefaultValue() { return 0; } @Override public Number getSample() { return permits.get(); } }); } acquireFailureCounter = statsLogger.getCounter("acquireFailure"); permitsMetric = statsLogger.getOpStatsLogger("permits"); }
public StatsFilter(StatsLogger stats) { this.stats = stats; this.outstandingAsync = stats.getCounter("outstandingAsync"); this.serviceExec = stats.getOpStatsLogger("serviceExec"); } }
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 ReadAheadCache(String streamName, StatsLogger statsLogger, AlertStatsLogger alertStatsLogger, AsyncNotification notification, int maxCachedRecords, boolean deserializeRecordSet, boolean traceDeliveryLatencyEnabled, long deliveryLatencyWarnThresholdMillis, Ticker ticker) { this.streamName = streamName; this.maxCachedRecords = maxCachedRecords; this.notification = notification; this.deserializeRecordSet = deserializeRecordSet; // create the readahead queue readAheadRecords = new LinkedBlockingQueue<LogRecordWithDLSN>(); // start the idle reader detection lastEntryProcessTime = Stopwatch.createStarted(ticker); // Flags to control delivery latency tracing this.traceDeliveryLatencyEnabled = traceDeliveryLatencyEnabled; this.deliveryLatencyWarnThresholdMillis = deliveryLatencyWarnThresholdMillis; // Stats StatsLogger readAheadStatsLogger = statsLogger.scope("readahead"); this.statsLogger = readAheadStatsLogger; this.alertStatsLogger = alertStatsLogger; this.readAheadDeliveryLatencyStat = readAheadStatsLogger.getOpStatsLogger("delivery_latency"); this.negativeReadAheadDeliveryLatencyStat = readAheadStatsLogger.getOpStatsLogger("negative_delivery_latency"); }
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; }
conf.getOutstandingWriteLimitDarkmode(), conf.getPerWriterOutstandingWriteLimit(), statsLogger.scope("streamWriteLimiter"), false, disableWriteLimitFeature); StatsLogger flushStatsLogger = statsLogger.scope("flush"); StatsLogger pFlushStatsLogger = flushStatsLogger.scope("periodic"); pFlushSuccesses = pFlushStatsLogger.getCounter("success"); pFlushMisses = pFlushStatsLogger.getCounter("miss"); StatsLogger transmitDataStatsLogger = statsLogger.scope("data"); transmitDataSuccesses = transmitDataStatsLogger.getCounter("success"); transmitDataMisses = transmitDataStatsLogger.getCounter("miss"); StatsLogger transmitStatsLogger = statsLogger.scope("transmit"); transmitDataPacketSize = transmitStatsLogger.getOpStatsLogger("packetsize"); StatsLogger transmitControlStatsLogger = statsLogger.scope("control"); transmitControlSuccesses = transmitControlStatsLogger.getCounter("success"); StatsLogger segWriterStatsLogger = statsLogger.scope("seg_writer"); writeTime = segWriterStatsLogger.getOpStatsLogger("write"); addCompleteTime = segWriterStatsLogger.scope("add_complete").getOpStatsLogger("callback"); addCompleteQueuedTime = segWriterStatsLogger.scope("add_complete").getOpStatsLogger("queued"); addCompleteDeferredTime = segWriterStatsLogger.scope("add_complete").getOpStatsLogger("deferred"); pendingWrites = segWriterStatsLogger.getCounter("pending"); StatsLogger transmitOutstandingLogger = perLogStatsLogger.scope("transmit").scope("outstanding"); transmitOutstandingLogger.registerGauge("requests", new Gauge<Number>() { @Override public Number getDefaultValue() {
public StreamAcquireLimiter(StreamManager streamManager, MovingAverageRate serviceRps, double serviceRpsLimit, StatsLogger statsLogger) { this.streamManager = streamManager; this.serviceRps = serviceRps; this.serviceRpsLimit = serviceRpsLimit; this.overlimitCounter = statsLogger.getCounter("overlimit"); }
@Override public <T extends Number> void registerGauge(String statName, Gauge<T> gauge) { first.registerGauge(statName, gauge); }
this.traceTaskExecution = traceTaskExecution; this.taskPendingStats = statsLogger.getOpStatsLogger("task_pending_time"); this.taskExecutionStats = statsLogger.getOpStatsLogger("task_execution_time"); statsLogger.registerGauge("pending_tasks", new Gauge<Number>() { @Override public Number getDefaultValue() { statsLogger.registerGauge("completed_tasks", new Gauge<Number>() { @Override public Number getDefaultValue() { statsLogger.registerGauge("total_tasks", new Gauge<Number>() { @Override public Number getDefaultValue() {
private LedgerHandleCache(BookKeeperClient bkc, String digestpw, StatsLogger statsLogger) { this.bkc = bkc; this.digestpw = digestpw; // Stats openStats = statsLogger.getOpStatsLogger("open_ledger"); openNoRecoveryStats = statsLogger.getOpStatsLogger("open_ledger_no_recovery"); }
public IndexPersistenceMgrStats(StatsLogger statsLogger, Supplier<Number> writeFileInfoCacheSizeSupplier, Supplier<Number> readFileInfoCacheSizeSupplier) { evictedLedgersCounter = statsLogger.getCounter(LEDGER_CACHE_NUM_EVICTED_LEDGERS); pendingGetFileInfoCounter = statsLogger.getCounter(PENDING_GET_FILE_INFO); writeFileInfoCacheSizeGauge = new Gauge<Number>() { @Override public Number getDefaultValue() { return 0; } @Override public Number getSample() { return writeFileInfoCacheSizeSupplier.get(); } }; statsLogger.registerGauge(WRITE_FILE_INFO_CACHE_SIZE, writeFileInfoCacheSizeGauge); readFileInfoCacheSizeGauge = new Gauge<Number>() { @Override public Number getDefaultValue() { return 0; } @Override public Number getSample() { return readFileInfoCacheSizeSupplier.get(); } }; statsLogger.registerGauge(READ_FILE_INFO_CACHE_SIZE, readFileInfoCacheSizeGauge); }
public void unregisterGauge() { if (this.statsLogger != null && this.outstandingGauge != null) { this.statsLogger.scope("permits").unregisterGauge("outstanding", this.outstandingGauge); } } }
public void unregisterGauge() { if (this.statsLogger != null && this.permitsGauge != null) { this.statsLogger.unregisterGauge(permitsGaugeLabel, permitsGauge); } } }
@Override public void removeScope(String scope, StatsLogger statsLogger) { if (!(statsLogger instanceof Two)) { return; } Two another = (Two) statsLogger; first.removeScope(scope, another.first); second.removeScope(scope, another.second); } }
/** * Create a future pool with stats exposed. * * @param futurePool underlying future pool to execute futures * @param statsLogger stats logger to receive exposed stats * @param traceTaskExecution flag to enable/disable exposing stats about task execution * @param traceTaskExecutionWarnTimeUs flag to enable/disable logging slow tasks * whose execution time is above this value */ public MonitoredFuturePool(FuturePool futurePool, StatsLogger statsLogger, boolean traceTaskExecution, long traceTaskExecutionWarnTimeUs) { this.futurePool = futurePool; this.traceTaskExecution = traceTaskExecution; this.traceTaskExecutionWarnTimeUs = traceTaskExecutionWarnTimeUs; this.statsLogger = statsLogger; this.taskPendingTime = statsLogger.getOpStatsLogger("task_pending_time"); this.taskExecutionTime = statsLogger.getOpStatsLogger("task_execution_time"); this.taskEnqueueTime = statsLogger.getOpStatsLogger("task_enqueue_time"); this.taskPendingCounter = statsLogger.getCounter("tasks_pending"); }
this.statsReceiver = statsReceiver; this.statsLogger = statsLogger; this.requestStat = this.statsLogger.getOpStatsLogger("requests"); this.exceptionsLogger = statsLogger.scope("exceptions"); this.dlErrorCodeLogger = statsLogger.scope("dl_error_code"); this.executorService = Executors.newCachedThreadPool(); this.random = new Random(System.currentTimeMillis());
public StatsLogger requestScope(String scopeName) { return requestStatsLogger.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 Counter requestCounter(String counterName) { return requestStatsLogger.getCounter(counterName); }