org.apache.bookkeeper.stats.OpStatsLogger Java Examples

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 byte[] decompress(byte[] data, int offset, int length, OpStatsLogger decompressionStat) {
    Preconditions.checkNotNull(data);
    Preconditions.checkArgument(offset >= 0 && offset < data.length);
    Preconditions.checkArgument(length >= 0);
    Preconditions.checkNotNull(decompressionStat);

    Stopwatch watch = Stopwatch.createStarted();
    // Assume that we have a compression ratio of 1/3.
    int outLength = length * 3;
    while (true) {
        try {
            byte[] decompressed = safeDecompressor.decompress(data, offset, length, outLength);
            decompressionStat.registerSuccessfulEvent(watch.elapsed(TimeUnit.MICROSECONDS));
            return decompressed;
        } catch (LZ4Exception e) {
            outLength *= 2;
        }
    }
}
 

protected Future<List<LogSegmentMetadata>> asyncGetLedgerList(final boolean forceFetch,
                                                                    final boolean fetchFullList,
                                                                    final Comparator<LogSegmentMetadata> comparator,
                                                                    final boolean throwOnEmpty) {
    final Promise<List<LogSegmentMetadata>> promise = new Promise<List<LogSegmentMetadata>>();
    final Stopwatch stopwatch = Stopwatch.createStarted();
    final OpStatsLogger statsLogger = fetchFullList ? getFullListStat : getFilteredListStat;
    asyncDoGetLedgerList(forceFetch, fetchFullList, comparator, throwOnEmpty)
            .addEventListener(new FutureEventListener<List<LogSegmentMetadata>>() {
                @Override
                public void onSuccess(List<LogSegmentMetadata> value) {
                    statsLogger.registerSuccessfulEvent(stopwatch.stop().elapsed(TimeUnit.MICROSECONDS));
                    promise.setValue(value);
                }

                @Override
                public void onFailure(Throwable cause) {
                    statsLogger.registerFailedEvent(stopwatch.stop().elapsed(TimeUnit.MICROSECONDS));
                    promise.setException(cause);
                }
            });
    return promise;
}
 

@Override
// Decompressed size is the same as the length of the data because this is an
// Identity compressor
public byte[] decompress(byte[] data, int offset, int length,
                         int decompressedSize, OpStatsLogger decompressionStat) {
    return decompress(data, offset, length, decompressionStat);
}
 

public AbstractStreamOp(String stream,
                        OpStatsLogger statsLogger,
                        Long checksum,
                        Feature checksumDisabledFeature) {
    this.stream = stream;
    this.opStatsLogger = statsLogger;
    // start here in case the operation is failed before executing.
    stopwatch.reset().start();
    this.checksum = checksum;
    this.checksumDisabledFeature = checksumDisabledFeature;
}
 

public OpStatsListener(OpStatsLogger opStatsLogger, Stopwatch stopwatch) {
    this.opStatsLogger = opStatsLogger;
    if (null == stopwatch) {
        this.stopwatch = Stopwatch.createStarted();
    } else {
        this.stopwatch = stopwatch;
    }
}
 

public OpStatsListener(OpStatsLogger opStatsLogger, Stopwatch stopwatch) {
    this.opStatsLogger = opStatsLogger;
    if (null == stopwatch) {
        this.stopwatch = Stopwatch.createStarted();
    } else {
        this.stopwatch = stopwatch;
    }
}
 

@Test
public void testStatsFailure() throws Exception {
    OpStatsLogger statsLogger = mock(OpStatsLogger.class);
    CompletableFuture<Long> underlyFuture = FutureUtils.createFuture();
    CompletableFuture<Long> statsFuture = FutureUtils.stats(
        underlyFuture,
        statsLogger,
        Stopwatch.createStarted());
    underlyFuture.completeExceptionally(new TestException());
    FutureUtils.result(FutureUtils.ignore(statsFuture));
    verify(statsLogger, times(1))
        .registerFailedEvent(anyLong(), eq(TimeUnit.MICROSECONDS));
}
 

@Test
public void testStatsSuccess() throws Exception {
    OpStatsLogger statsLogger = mock(OpStatsLogger.class);
    CompletableFuture<Long> underlyFuture = FutureUtils.createFuture();
    CompletableFuture<Long> statsFuture = FutureUtils.stats(
        underlyFuture,
        statsLogger,
        Stopwatch.createStarted());
    underlyFuture.complete(1234L);
    FutureUtils.result(statsFuture);
    verify(statsLogger, times(1))
        .registerSuccessfulEvent(anyLong(), eq(TimeUnit.MICROSECONDS));
}
 

public OpStatsListener(OpStatsLogger opStatsLogger, Stopwatch stopwatch) {
    this.opStatsLogger = opStatsLogger;
    if (null == stopwatch) {
        this.stopwatch = Stopwatch.createStarted();
    } else {
        this.stopwatch = stopwatch;
    }
}
 

@Override
public byte[] compress(byte[] data, int offset, int length, OpStatsLogger compressionStat) {
    Preconditions.checkNotNull(data);
    Preconditions.checkArgument(offset >= 0 && offset < data.length);
    Preconditions.checkArgument(length >= 0);
    Preconditions.checkNotNull(compressionStat);

    Stopwatch watch = Stopwatch.createStarted();
    byte[] compressed = compressor.compress(data, offset, length);
    compressionStat.registerSuccessfulEvent(watch.elapsed(TimeUnit.MICROSECONDS));
    return compressed;
}
 

public AbstractStreamOp(String stream,
                        OpStatsLogger statsLogger,
                        Long checksum,
                        Feature checksumDisabledFeature) {
    this.stream = stream;
    this.opStatsLogger = statsLogger;
    // start here in case the operation is failed before executing.
    stopwatch.reset().start();
    this.checksum = checksum;
    this.checksumDisabledFeature = checksumDisabledFeature;
}
 

@Override
// length parameter is ignored here because of the way the fastDecompressor works.
public byte[] decompress(byte[] data, int offset, int length, int decompressedSize,
                         OpStatsLogger decompressionStat) {
    Preconditions.checkNotNull(data);
    Preconditions.checkArgument(offset >= 0 && offset < data.length);
    Preconditions.checkArgument(length >= 0);
    Preconditions.checkArgument(decompressedSize >= 0);
    Preconditions.checkNotNull(decompressionStat);

    Stopwatch watch = Stopwatch.createStarted();
    byte[] decompressed = fastDecompressor.decompress(data, offset, decompressedSize);
    decompressionStat.registerSuccessfulEvent(watch.elapsed(TimeUnit.MICROSECONDS));
    return decompressed;
}
 

protected StreamAdminOp(String stream,
                        StreamManager streamManager,
                        OpStatsLogger statsLogger,
                        Long checksum,
                        Feature checksumDisabledFeature) {
    this.stream = stream;
    this.streamManager = streamManager;
    this.opStatsLogger = statsLogger;
    // start here in case the operation is failed before executing.
    stopwatch.reset().start();
    this.checksum = checksum;
    this.checksumDisabledFeature = checksumDisabledFeature;
}
 

public OpStatsLogger requestLatencyStat(String opName) {
    return requestStatsLogger.getOpStatsLogger(opName);
}
 

public OpStatsLogger streamRequestLatencyStat(String streamName, String opName) {
    return streamRequestStatsLogger(streamName).getOpStatsLogger(opName);
}
 

/**
 * Open the log segment.
 *
 * @param metadata
 *          the log segment metadata
 * @param fence
 *          whether to fence the log segment during open
 * @return a future presenting the open result.
 */
public Future<LedgerDescriptor> asyncOpenLedger(LogSegmentMetadata metadata, boolean fence) {
    final Stopwatch stopwatch = Stopwatch.createStarted();
    final OpStatsLogger openStatsLogger = fence ? openStats : openNoRecoveryStats;
    final Promise<LedgerDescriptor> promise = new Promise<LedgerDescriptor>();
    final LedgerDescriptor ledgerDesc = new LedgerDescriptor(metadata.getLedgerId(), metadata.getLogSegmentSequenceNumber(), fence);
    RefCountedLedgerHandle refhandle = handlesMap.get(ledgerDesc);
    if (null == refhandle) {
        asyncOpenLedger(ledgerDesc, new AsyncCallback.OpenCallback() {
            @Override
            public void openComplete(int rc, LedgerHandle lh, Object ctx) {
                if (BKException.Code.OK != rc) {
                    promise.setException(BKException.create(rc));
                    return;
                }
                RefCountedLedgerHandle newRefHandle = new RefCountedLedgerHandle(lh);
                RefCountedLedgerHandle oldRefHandle = handlesMap.putIfAbsent(ledgerDesc, newRefHandle);
                if (null != oldRefHandle) {
                    oldRefHandle.addRef();
                    if (newRefHandle.removeRef()) {
                        newRefHandle.handle.asyncClose(new AsyncCallback.CloseCallback() {
                            @Override
                            public void closeComplete(int i, LedgerHandle ledgerHandle, Object o) {
                                // No action necessary
                            }
                        }, null);
                    }
                }
                promise.setValue(ledgerDesc);
            }
        }, null);
    } else {
        refhandle.addRef();
        promise.setValue(ledgerDesc);
    }
    return promise.addEventListener(new FutureEventListener<LedgerDescriptor>() {
        @Override
        public void onSuccess(LedgerDescriptor value) {
            openStatsLogger.registerSuccessfulEvent(stopwatch.elapsed(TimeUnit.MICROSECONDS));
        }

        @Override
        public void onFailure(Throwable cause) {
            openStatsLogger.registerFailedEvent(stopwatch.elapsed(TimeUnit.MICROSECONDS));
        }
    });
}
 

protected static OpStatsLogger requestStat(StatsLogger statsLogger, String opName) {
    return requestLogger(statsLogger).getOpStatsLogger(opName);
}
 

@Override
public byte[] compress(byte[] data, int offset, int length, OpStatsLogger compressionStat) {
    Preconditions.checkNotNull(data);
    Preconditions.checkArgument(length >= 0);
    return Arrays.copyOfRange(data, offset, offset + length);
}
 

@Override
public byte[] decompress(byte[] data, int offset, int length, OpStatsLogger decompressionStat) {
    Preconditions.checkNotNull(data);
    return Arrays.copyOfRange(data, offset, offset + length);
}
 

@Override
public OpStatsLogger getOpStatsLogger(String name) {
    return provider.opStats.computeIfAbsent(completeName(name), x -> new DataSketchesOpStatsLogger());
}
 

protected AbstractWriteOp(String stream,
                          OpStatsLogger statsLogger,
                          Long checksum,
                          Feature checksumDisabledFeature) {
    super(stream, statsLogger, checksum, checksumDisabledFeature);
}
 

OpStatsLoggerAdaptor(OpStatsLogger statsLogger) {
    this.statsLogger = statsLogger;
}
 

public OpStatsListener(OpStatsLogger opStatsLogger) {
    this(opStatsLogger, null);
}
 

public OpStatsListener(OpStatsLogger opStatsLogger) {
    this(opStatsLogger, null);
}
 

public OpStatsListener(OpStatsLogger opStatsLogger) {
    this(opStatsLogger, null);
}
 

public static OpStatsLogger requestStat(StatsLogger statsLogger, String opName) {
    return requestLogger(statsLogger).getOpStatsLogger(opName);
}
 

public OpStatsLogger streamRequestLatencyStat(Partition partition, String opName) {
    return streamRequestStatsLogger(partition).getOpStatsLogger(opName);
}
 

public OpStatsLogger requestLatencyStat(String opName) {
    return requestStatsLogger.getOpStatsLogger(opName);
}
 

protected AbstractWriteOp(String stream,
                          OpStatsLogger statsLogger,
                          Long checksum,
                          Feature checksumDisabledFeature) {
    super(stream, statsLogger, checksum, checksumDisabledFeature);
}