@Override public void operationComplete(int rc, List<LogSegmentMetadata> result) { long elapsedMicros = stopwatch.stop().elapsed(TimeUnit.MICROSECONDS); if (KeeperException.Code.OK.intValue() != rc) { getListStat.registerFailedEvent(elapsedMicros); } else { if (LogSegmentFilter.DEFAULT_FILTER == segmentFilter) { isFullListFetched.set(true); } getListStat.registerSuccessfulEvent(elapsedMicros); } finalCallback.operationComplete(rc, result); } };
@Override public OpStatsData toOpStatsData() { // Eventually consistent. return firstLogger.toOpStatsData(); }
@Override public void registerSuccessfulEvent(long l) { firstLogger.registerSuccessfulEvent(l); secondLogger.registerSuccessfulEvent(l); }
public ByteBuf readEntry(long ledgerId, long entryId) throws IOException, NoLedgerException { long requestNanos = MathUtils.nowInNano(); boolean success = false; int entrySize = 0; try { LedgerDescriptor handle = handles.getReadOnlyHandle(ledgerId); if (LOG.isTraceEnabled()) { LOG.trace("Reading {}@{}", entryId, ledgerId); } ByteBuf entry = handle.readEntry(entryId); bookieStats.getReadBytes().add(entry.readableBytes()); success = true; return entry; } finally { long elapsedNanos = MathUtils.elapsedNanos(requestNanos); if (success) { bookieStats.getReadEntryStats().registerSuccessfulEvent(elapsedNanos, TimeUnit.NANOSECONDS); bookieStats.getReadBytesStats().registerSuccessfulValue(entrySize); } else { bookieStats.getReadEntryStats().registerFailedEvent(elapsedNanos, TimeUnit.NANOSECONDS); bookieStats.getReadEntryStats().registerFailedValue(entrySize); } } }
@Override public void registerFailedEvent(long l) { firstLogger.registerFailedEvent(l); secondLogger.registerFailedEvent(l); }
@Override public void run() { long now = System.currentTimeMillis(); try { synch(); syncSize.registerSuccessfulValue(unsyncedCount); syncBytes.registerSuccessfulValue(unsyncedBytes); for (LogEntryHolderFuture e : syncNeeded) { statsEntrySyncLatency.registerSuccessfulEvent(now - e.timestamp, TimeUnit.MILLISECONDS); e.syncDone(); } syncNeeded = null; } catch (Throwable t) { failed = true; LOGGER.log(Level.SEVERE, "general commit log failure on " + FileCommitLog.this.logDirectory, t); for (LogEntryHolderFuture e : syncNeeded) { statsEntrySyncLatency.registerFailedEvent(now - e.timestamp, TimeUnit.MILLISECONDS); } } }
@Override public void onSuccess(LogRecordWithDLSN value) { recoverLastEntryStats.registerSuccessfulEvent( stopwatch.stop().elapsed(TimeUnit.MICROSECONDS), TimeUnit.MICROSECONDS); recoverScannedEntriesStats.registerSuccessfulValue(numRecordsScanned.get()); }
@Override public void registerSuccessfulValue(long l) { firstLogger.registerSuccessfulValue(l); secondLogger.registerSuccessfulValue(l); }
@Override public void handleBookiesThatLeft(Set<BookieSocketAddress> leftBookies) { for (BookieSocketAddress addr : leftBookies) { try { BookieNode node = knownBookies.remove(addr); if (null != node) { topology.remove(node); if (this.isWeighted) { this.bookieInfoMap.remove(node); } bookiesLeftCounter.registerSuccessfulValue(1L); if (LOG.isDebugEnabled()) { LOG.debug("Cluster changed : bookie {} left from cluster.", addr); } } } catch (Throwable t) { LOG.error("Unexpected exception while handling leaving bookie {}", addr, t); if (bookiesLeftCounter != null) { bookiesLeftCounter.registerFailedValue(1L); } // no need to re-throw; we want to process the rest of the bookies // exception anyways will be caught/logged/suppressed in the ZK's event handler } } }
@Override public void registerFailedValue(long l) { firstLogger.registerFailedValue(l); secondLogger.registerFailedValue(l); }
@Override public void onSuccess(ZKDistributedLock lock) { // if re-acquire successfully, clear the state. synchronized (ZKDistributedLock.this) { lockReacquireFuture = null; } reacquireStats.registerSuccessfulEvent(stopwatch.elapsed(TimeUnit.MICROSECONDS)); }
long elapsedNanos = MathUtils.elapsedNanos(requestNanos); if (success) { bookieStats.getRecoveryAddEntryStats().registerSuccessfulEvent(elapsedNanos, TimeUnit.NANOSECONDS); bookieStats.getAddBytesStats().registerSuccessfulValue(entrySize); } else { bookieStats.getRecoveryAddEntryStats().registerFailedEvent(elapsedNanos, TimeUnit.NANOSECONDS); bookieStats.getAddBytesStats().registerFailedValue(entrySize);
@Override public void onFailure(Throwable cause) { openStatsLogger.registerFailedEvent(stopwatch.elapsed(TimeUnit.MICROSECONDS)); } });
journalFormatVersionToWrite, getBufferedChannelBuilder()); journalStats.getJournalCreationStats().registerSuccessfulEvent( journalCreationWatcher.stop().elapsed(TimeUnit.NANOSECONDS), TimeUnit.NANOSECONDS); if (dequeueStartTime != 0) { journalStats.getJournalProcessTimeStats() .registerSuccessfulEvent(MathUtils.elapsedNanos(dequeueStartTime), TimeUnit.NANOSECONDS); dequeueStartTime = MathUtils.nowInNano(); journalStats.getJournalQueueStats() .registerSuccessfulEvent(MathUtils.elapsedNanos(qe.enqueueTime), TimeUnit.NANOSECONDS); } else { long pollWaitTimeNanos = maxGroupWaitInNanos .registerSuccessfulEvent(MathUtils.elapsedNanos(qe.enqueueTime), TimeUnit.NANOSECONDS); journalStats.getJournalFlushStats().registerSuccessfulEvent( journalFlushWatcher.stop().elapsed(TimeUnit.NANOSECONDS), TimeUnit.NANOSECONDS); .registerSuccessfulValue(numEntriesToFlush); journalStats.getForceWriteBatchBytesStats() .registerSuccessfulValue(batchSize);
@Override public void registerSuccessfulValue(long l) { firstLogger.registerSuccessfulValue(l); secondLogger.registerSuccessfulValue(l); }
private void submitCallback(int rc) { if (BKException.Code.OK == rc) { clientCtx.getClientStats().getRecoverAddCountLogger().registerSuccessfulValue(writeCount.get()); clientCtx.getClientStats().getRecoverReadCountLogger().registerSuccessfulValue(readCount.get()); promise.complete(lh); } else { clientCtx.getClientStats().getRecoverAddCountLogger().registerFailedValue(writeCount.get()); clientCtx.getClientStats().getRecoverReadCountLogger().registerFailedValue(readCount.get()); promise.completeExceptionally(BKException.create(rc)); } }
@Override public void registerFailedValue(long l) { firstLogger.registerFailedValue(l); secondLogger.registerFailedValue(l); }
protected List<LogSegmentMetadata> getLedgerList(boolean forceFetch, boolean fetchFullList, Comparator<LogSegmentMetadata> comparator, boolean throwOnEmpty) throws IOException { Stopwatch stopwatch = Stopwatch.createStarted(); boolean success = false; try { List<LogSegmentMetadata> segments = doGetLedgerList(forceFetch, fetchFullList, comparator, throwOnEmpty); success = true; return segments; } finally { OpStatsLogger statsLogger = fetchFullList ? getFullListStat : getFilteredListStat; if (success) { statsLogger.registerSuccessfulEvent(stopwatch.stop().elapsed(TimeUnit.MICROSECONDS)); } else { statsLogger.registerFailedEvent(stopwatch.stop().elapsed(TimeUnit.MICROSECONDS)); } } }
@Override public void onSuccess(DLSN value) { requestStat.registerSuccessfulEvent(System.currentTimeMillis() - requestMillis); }