@Override public void run() { final long actualDelay = clock.nanoTime() - startTimeNs; addToPendingNanos(-actualDelay); callback.run(); } }, delay, TimeUnit.NANOSECONDS);
@Override public void run() { final long actualDelay = clock.nanoTime() - startTimeNs; addToPendingNanos(-actualDelay); callback.run(); } }, delay, TimeUnit.NANOSECONDS);
@Override public void run() { final long actualDelay = clock.nanoTime() - startTimeNs; addToPendingNanos(-actualDelay); callback.run(); } }, delay, TimeUnit.NANOSECONDS);
@Override public void run() { final long actualDelay = clock.nanoTime() - startTimeNs; addToPendingNanos(-actualDelay); callback.run(); } }, delay, TimeUnit.NANOSECONDS);
@Override public void run() { final long actualDelay = clock.nanoTime() - startTimeNs; addToPendingNanos(-actualDelay); callback.run(); } }, delay, TimeUnit.NANOSECONDS);
@Override public void flush() { try { incCounter(metrics.numFlushes); long startNs = clock.nanoTime(); asyncTable.flush(); updateTimer(metrics.flushNs, clock.nanoTime() - startNs); } catch (Exception e) { String errMsg = "Failed to flush remote store"; logger.error(errMsg, e); throw new SamzaException(errMsg, e); } }
protected <T> CompletableFuture<T> instrument(Func1<T> func, Counter counter, Timer timer) { incCounter(counter); final long startNs = clock.nanoTime(); CompletableFuture<T> ioFuture = func.apply(); if (callbackExecutor != null) { ioFuture.thenApplyAsync(r -> { updateTimer(timer, clock.nanoTime() - startNs); return r; }, callbackExecutor); } else { ioFuture.thenApply(r -> { updateTimer(timer, clock.nanoTime() - startNs); return r; }); } return ioFuture; } }
/** * Handle timer ticks for this {@link OperatorImpl} and propagate the results and timer tick to registered operators. * <p> * Delegates to {@link #handleTimer(MessageCollector, TaskCoordinator)} for handling the timer tick. * * @param collector the {@link MessageCollector} in the context * @param coordinator the {@link TaskCoordinator} in the context */ public final void onTimer(MessageCollector collector, TaskCoordinator coordinator) { long startNs = this.highResClock.nanoTime(); Collection<RM> results = handleTimer(collector, coordinator); long endNs = this.highResClock.nanoTime(); this.handleTimerNs.update(endNs - startNs); results.forEach(rm -> this.registeredOperators.forEach(op -> op.onMessage(rm, collector, coordinator))); this.registeredOperators.forEach(op -> op.onTimer(collector, coordinator)); }
@Override public CompletableFuture<Void> deleteAsync(K key) { incCounter(metrics.numDeletes); long startNs = clock.nanoTime(); Preconditions.checkNotNull(table, "Cannot delete from a read-only table: " + table); return table.deleteAsync(key).handle((result, e) -> { if (e != null) { throw new SamzaException("Failed to delete the record for " + key, e); } else if (!isWriteAround) { cache.delete(key); } updateTimer(metrics.deleteNs, clock.nanoTime() - startNs); return result; }); }
@Override public CompletableFuture<Void> deleteAllAsync(List<K> keys) { incCounter(metrics.numDeleteAlls); long startNs = clock.nanoTime(); Preconditions.checkNotNull(table, "Cannot delete from a read-only table: " + table); return table.deleteAllAsync(keys).handle((result, e) -> { if (e != null) { throw new SamzaException("Failed to delete the record for " + keys, e); } else if (!isWriteAround) { cache.deleteAll(keys); } updateTimer(metrics.deleteAllNs, clock.nanoTime() - startNs); return result; }); }
private void setActualDelay(long actualDelayNs) { Mockito.when(clock.nanoTime()).thenReturn(0L).thenReturn(actualDelayNs); }
@Override public CompletableFuture<Void> putAllAsync(List<Entry<K, V>> records) { incCounter(metrics.numPutAlls); long startNs = clock.nanoTime(); Preconditions.checkNotNull(table, "Cannot write to a read-only table: " + table); return table.putAllAsync(records).handle((result, e) -> { if (e != null) { throw new SamzaException("Failed to put records " + records, e); } else if (!isWriteAround) { cache.putAll(records); } updateTimer(metrics.putAllNs, clock.nanoTime() - startNs); return result; }); }
private void setWorkTime(long workTimeNanos) { Mockito.when(clock.nanoTime()).thenReturn(0L).thenReturn(workTimeNanos); }
@Override public CompletableFuture<Void> putAsync(K key, V value) { incCounter(metrics.numPuts); Preconditions.checkNotNull(table, "Cannot write to a read-only table: " + table); long startNs = clock.nanoTime(); return table.putAsync(key, value).handle((result, e) -> { if (e != null) { throw new SamzaException(String.format("Failed to put a record, key=%s, value=%s", key, value), e); } else if (!isWriteAround) { if (value == null) { cache.delete(key); } else { cache.put(key, value); } } updateTimer(metrics.putNs, clock.nanoTime() - startNs); return result; }); }
@Override public void run() { try { containerMetrics.commits().inc(); long startTime = clock.nanoTime(); task.commit(); containerMetrics.commitNs().update(clock.nanoTime() - startTime); state.doneCommit(); } catch (Throwable t) { log.error("Task {} commit failed", task.taskName(), t); abort(t); } finally { log.trace("Task {} commit completed", task.taskName()); resume(); } } };
@Override public void run() { try { ReadableCoordinator coordinator = new ReadableCoordinator(task.taskName()); long startTime = clock.nanoTime(); task.scheduler(coordinator); containerMetrics.timerNs().update(clock.nanoTime() - startTime); coordinatorRequests.update(coordinator); state.doneScheduler(); } catch (Throwable t) { log.error("Task {} scheduler failed", task.taskName(), t); abort(t); } finally { log.trace("Task {} scheduler completed", task.taskName()); resume(); } } };
@Override public void run() { try { ReadableCoordinator coordinator = new ReadableCoordinator(task.taskName()); long startTime = clock.nanoTime(); task.scheduler(coordinator); containerMetrics.timerNs().update(clock.nanoTime() - startTime); coordinatorRequests.update(coordinator); state.doneScheduler(); } catch (Throwable t) { log.error("Task {} scheduler failed", task.taskName(), t); abort(t); } finally { log.trace("Task {} scheduler completed", task.taskName()); resume(); } } };