@Override public void init(ProcessorContext processorContext) { this.processorContext = processorContext; delegateProcessor.init(processorContext); }
@Override public TimestampExtractor create(final int columnIndex) { return new FailOnInvalidTimestamp(); }
@Override public void close() { delegateProcessor.close(); } }
@Override @SuppressWarnings("unchecked") public void init(ProcessorContext context) { reservedStocksStore = (KeyValueStore<Product, Long>) context .getStateStore(RESERVED_STOCK_STORE_NAME); }
static void addTags(ProcessorContext processorContext, SpanCustomizer result) { result.tag(KafkaStreamsTags.KAFKA_STREAMS_APPLICATION_ID_TAG, processorContext.applicationId()); result.tag(KafkaStreamsTags.KAFKA_STREAMS_TASK_ID_TAG, processorContext.taskId().toString()); }
@Override public DeserializationHandlerResponse handle( final ProcessorContext context, final ConsumerRecord<byte[], byte[]> record, final Exception exception ) { log.warn( "Exception caught during Deserialization, " + "taskId: {}, topic: {}, partition: {}, offset: {}", context.taskId(), record.topic(), record.partition(), record.offset(), exception ); StreamsErrorCollector.recordError(context.applicationId(), record.topic()); return DeserializationHandlerResponse.CONTINUE; }
@Override public Cancellable schedule(final Duration interval, final PunctuationType type, final Punctuator callback) throws IllegalArgumentException { return delegate.schedule(interval, type, callback); }
private boolean isDuplicate(final E eventId) { long eventTime = context.timestamp(); WindowStoreIterator<Long> timeIterator = eventIdStore.fetch( eventId, eventTime - leftDurationMs, eventTime + rightDurationMs); boolean isDuplicate = timeIterator.hasNext(); timeIterator.close(); return isDuplicate; }
Span nextSpan(ProcessorContext context) { TraceContextOrSamplingFlags extracted = extractor.extract(context.headers()); Span result = tracing.tracer().nextSpan(extracted); if (!result.isNoop()) { addTags(context, result); } return result; }
@Override public void process(K k, V v) { Span span = kafkaStreamsTracing.nextSpan(processorContext); if (!span.isNoop()) { span.name(spanName); span.start(); } try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { delegateProcessor.process(k, v); } catch (RuntimeException | Error e) { span.error(e); // finish as an exception means the callback won't finish the span throw e; } finally { span.finish(); } }
@Override public void init(final ProcessorContext context, final StateStore root) { innerState.init(context, root); }
@Override public void register(final StateStore store, final StateRestoreCallback stateRestoreCallback) { delegate.register(store, stateRestoreCallback); }
/** * @throws StreamsException if user provided {@link StateRestoreListener} raises an exception in * {@link StateRestoreListener#onRestoreEnd(TopicPartition, String, long)} */ @Override public void onRestoreEnd(final TopicPartition topicPartition, final String storeName, final long totalRestored) { userRestoreListener.onRestoreEnd(topicPartition, storeName, totalRestored); storeRestoreListener.onRestoreEnd(topicPartition, storeName, totalRestored); }
/** * Forward the key/value pair to one of the downstream processors designated by the downstream processor name. * @param childName name of downstream processor * @return a new {@link To} instance configured with {@code childName} */ public static To child(final String childName) { return new To(childName, -1); }
/** * @throws StreamsException if user provided {@link StateRestoreListener} raises an exception in * {@link StateRestoreListener#onRestoreStart(TopicPartition, String, long, long)} */ @Override public void onRestoreStart(final TopicPartition topicPartition, final String storeName, final long startingOffset, final long endingOffset) { userRestoreListener.onRestoreStart(topicPartition, storeName, startingOffset, endingOffset); storeRestoreListener.onRestoreStart(topicPartition, storeName, startingOffset, endingOffset); }
@Override public StreamsMetrics metrics() { return delegate.metrics(); }
@Override @SuppressWarnings("unchecked") public void init(final ProcessorContext context) { this.context = context; eventIdStore = (WindowStore<E, Long>) context.getStateStore(storeName); }
public KeyValue<K, V> transform(final K key, final V value) { E eventId = idExtractor.apply(key, value); if (eventId == null) { return KeyValue.pair(key, value); } else { KeyValue<K, V> output; if (isDuplicate(eventId)) { output = null; updateTimestampOfExistingEventToPreventExpiry(eventId, context.timestamp()); } else { output = KeyValue.pair(key, value); rememberNewEvent(eventId, context.timestamp()); } return output; } }
@SuppressWarnings("unchecked") @Override public void init(ProcessorContext context) { stateStore = (KeyValueStore<String, Long>) context.getStateStore(stateStoreName); }