liveBookmanning.com

What you will learn in Kafka Streams in Action, Second Edition

Event-driven applications and microservices

by William P. Bejeck Jr.
Foreword by Jun Rao

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• schema registrySchema Registry is a service for storing and validating schemas so that serialized records remain compatible between producers and consumers.
• processing nodeThe Processor API is the lower-level Kafka Streams programming interface for processing records with direct access to record context and metadata.
• schemaA schema is a formal description of the structure and meaning of data records exchanged between software components, expressed in Apache Avro's schema format.
• timestampA timestamp is a time value associated with a record that indicates when the represented event occurred or is ordered relative to other events.
• Spring for Apache KafkaSpring Kafka is a Spring project that provides integration components for developing applications that produce, consume, and process Kafka records.
• interactive queryInteractive Queries is a Kafka Streams feature that exposes locally maintained state-store information for direct querying by applications.
• Kafka StreamsThe Kafka Streams API is the programming interface for building stream-processing applications with Kafka Streams.
• windowingA windowed operation processes records within bounded time intervals and produces results associated with those intervals.
• ksqlDB streamA base stream is a ksqlDB stream created directly from a Kafka topic to expose its records for subsequent queries.
• state storeA state store is a Kafka Streams component that persistently maintains intermediate processing state for an application.
• offsetAn offset is a nonnegative integer that identifies a record's logical position within a Kafka partition and advances sequentially as records are appended.
• serializerThe Kafka Serializer interface defines the API that a serializer implementation uses to convert data into bytes.
• protocol bufferProtocol Buffers is a language-neutral, platform-neutral mechanism for serializing structured data using defined message schemas.
• continuous queryA push query is a continuous ksqlDB query that emits changing results to the client that issued it without persisting those results in a topic.
• pull queryA pull query retrieves point-in-time results from a materialized store instead of continuously receiving pushed results.
• ksqlDB tableA ksqlDB table is a persistent queryable representation of the latest value for each record key produced by a stateful query.
• punctuationPunctuator.punctuate is the Kafka Streams callback method executed when scheduled punctuation occurs.
• Spring containerThe Spring container is the Spring runtime component that creates application objects and wires their dependencies according to configuration and annotations.
• stream timeStream time is the greatest event timestamp observed by a Kafka Streams processor and its task-level notion of current time.
• persistent queryA persistent query is a server-side ksqlDB query whose continuously computed results are stored in a Kafka topic for later consumption.
• AvroApache Avro is a data serialization system that uses schemas and supports language-independent serialization, code generation, and schema evolution.
• connectorA connector is a Kafka Connect component that coordinates tasks for moving data between Kafka and an external system.
• Kafka ConnectKafka Connect is a framework for importing data into Apache Kafka and exporting data from it through connectors and related processing components.
• partitionA Kafka partition is an ordered, append-only subdivision of a topic that stores records and assigns each record a unique offset within that partition.
• time windowWindow is a Kafka Streams API type representing the time interval associated with a windowed record or aggregation.
• schema idA schema identifier is a unique numeric identifier assigned by Schema Registry to a registered schema.
• sink connectorSinkConnector is the Kafka Connect connector type that generates tasks for exporting data from Kafka to an external system.
• copartitioningCo-partitioning is the arrangement in which participating Kafka Streams inputs have the same partition count and compatible key types so corresponding records can be processed together.
• taskA StreamTask is a Kafka Streams runtime unit that processes records for assigned input partitions and maintains its associated local state.
• KTableKTable is a Kafka Streams abstraction representing the latest value associated with each key in a table-like changelog stream.
• ROWTIMEROWTIME is a ksqlDB system column containing the timestamp of the underlying Kafka record.
• source connectorSourceConnector is the Kafka Connect connector type used to configure tasks that import records from an external system into Kafka.
• deserializerThe Kafka Deserializer interface defines the API that a deserializer implementation uses to convert bytes into data.
• statefulnessA stateful application is a program that retains processing state across multiple input events.
• KStreamKStream is a Kafka Streams abstraction representing an unbounded stream of key-value records and supporting record-by-record processing operations.
• dependency injectionDependency injection is a design technique in which an object's required dependencies are supplied by external configuration or a framework rather than created by the object itself.
• Spring beanA Spring bean is an object managed and configured by the Spring application container.
• consumer group rebalancingA consumer group rebalance is the redistribution of Kafka topic partitions among consumers in a consumer group.
• table-to-table joinA table-table join is a Kafka Streams operation that combines two KTable representations and recalculates results when either table changes.
• source pointA source node is the root node of a Kafka Streams topology that consumes records and forwards them into the application.
• foreign key associationA KTable foreign key join combines table records by a foreign key derived from the joining record rather than requiring identical primary keys.
• @KafkaListenerA Kafka listener is a Spring Kafka listener component that receives records from Kafka through a consumer.
• processor topologyA Kafka Streams topology is a directed graph of source, processor, and sink nodes that defines how records flow through a stream-processing application.
• joinA join is an operation that combines records from two data streams or related data sources according to matching criteria.
• JSON SchemaJSON Schema is a vocabulary and specification for describing and validating the structure and constraints of JSON data.
• SerdeSerdes is a Kafka Streams utility class that provides factory methods for standard Serde implementations.
• @Autowired@Autowired is a Spring annotation that marks a constructor, field, or method for automatic dependency injection.
• KafkaTemplateKafkaTemplate is a Spring Kafka class that provides high-level methods for sending records to Kafka topics.
• mapValuesKStream.mapValues is a Kafka Streams operation that maps each record value to a new value while retaining the record key.
• MaterializedMaterialized is a Kafka Streams DSL class for specifying how a stateful operation's result is materialized, including its state-store name and Serdes.
• repartitionKStream.repartition is a Kafka Streams operation that explicitly redistributes stream records into a repartition topic using configurable partitioning settings.
• ConcurrentKafkaListenerContainerFactoryConcurrentKafkaListenerContainerFactory is a Spring Kafka factory for creating listener containers with configurable consumer concurrency and behavior.
• ListenableFutureListenableFuture is a Spring abstraction representing the eventual result of an asynchronous operation and supporting completion callbacks.
• data groupingGroupBy is a Kafka Streams DSL operation that remaps stream records to a selected key before grouping them for downstream processing.
• structStruct is a Kafka Connect data structure that stores record field values together with schema-defined type information.
• changelogA changelog is an append-oriented record sequence that retains the latest record for each key.
• suppressionSuppression is a Kafka Streams technique that delays intermediate results and emits a result only when its configured conditions are met.
• group.idgroup.id is a Kafka consumer configuration identifying the consumer group to which a consumer belongs.
• Kafka transactionA Kafka transaction is an atomic unit that groups record production and related offset commits so they either all succeed or all abort.
• data aggregationaggregate is a Kafka Streams grouped-stream or grouped-table operation that computes a result by initializing and incrementally updating an aggregate.
• time-windowed aggregationA windowed aggregate is an aggregate result computed from the records assigned to a particular time window.
• ksqlDBA ksqlDB server is the server-side service that executes ksqlDB statements and manages continuously running stream-processing applications.
• predicatePredicate is a boolean-valued functional interface that evaluates a record to determine whether it belongs in a branch.
• testTesting is the systematic evaluation of software behavior against expected results under defined inputs and conditions.
• topicA Kafka topic is a named, append-only stream of records that producers publish to and consumers read from.
• event streaming systemAn event-streaming platform is software infrastructure that captures, transfers, stores, and makes event data available for processing.
• primary keyA primary key is a field or set of fields that uniquely identifies a row in a database table.
• composite keyA composite key is a record or row identifier formed from multiple fields.
• SpringSpring is an open-source Java application framework that provides dependency injection, configuration, and other infrastructure for building applications.
• converterA converter is a Kafka Connect component that changes data between Connect's internal representation and a serialization format used by Kafka or an external system.
• TopologyTestDriverTopologyTestDriver is a Kafka Streams test utility that runs a topology in memory and provides test input, output, and state-store access.
• at-least-once deliveryAt-least-once delivery is a processing guarantee that prevents loss of records but permits a record to be processed more than once.
• at-most-once deliveryAt-most-once delivery is a processing guarantee that avoids reprocessing by committing before processing completes, at the risk of losing records.
• Spring BootSpring Boot is a Spring-based framework that simplifies application development through auto-configuration, convention-based defaults, and embedded application services.
• integration testIntegration testing verifies interactions and behavior among multiple software components and their dependencies.
• Apache KafkaApache Kafka is a distributed event streaming platform for publishing, storing, and processing streams of records.
• cooperative rebalanceCooperative rebalancing is a Kafka rebalance protocol that incrementally changes partition assignments while allowing unaffected assignments to continue.
• mockingA mock object is a test double that implements a collaborator's interface while providing explicitly configured behavior instead of performing the collaborator's real operations.
• topic name strategyTopicNameStrategy is a Schema Registry subject naming strategy that derives separate key and value subject names from a Kafka topic name.
• TestInputTopicTestInputTopic is a Kafka Streams test utility representing an input topic and providing methods for piping test records into a topology.
• TestOutputTopicTestOutputTopic is a Kafka Streams test utility representing a topology output topic and providing methods for reading produced records.
• GlobalKTableGlobalKTable is a Kafka Streams abstraction that stores all records of an underlying topic on every application instance without partition sharding.
• consumer groupA consumer group is a set of Kafka consumers that jointly consume a topic's partitions, with each partition assigned to at most one group member at a time.
• exactly-once deliveryExactly-once semantics is a message-processing guarantee that each input record's effects are applied once without duplicate results despite retries or failures.
• producer idempotenceenable.idempotence is a Kafka producer configuration that enables idempotent record delivery.
• Kafka producerKafkaProducer is the Kafka client API class that publishes records to Kafka topics.
• throughputThroughput is the amount of data or number of records processed or transferred during a unit of time.
• single message transformationA Single Message Transform (SMT) is a lightweight Kafka Connect transformation that modifies each record independently as it passes through a connector.
• stream-table joinA stream-table join combines records from a KStream with corresponding records in a KTable according to matching keys.
• replicationReplication is the process of maintaining copies of records on multiple brokers to preserve data despite broker or machine failures.
• windowed state storeWindowed is a Kafka Streams type that combines a record key with the time window associated with that key.
• schema referenceA schema reference is a schema-defined link to another schema that enables schemas to share common definitions.
• toStream()toStream is a Kafka Streams operation that converts a KTable result into a KStream.
• AggregatorAggregator is a Kafka Streams functional interface whose implementation updates an aggregate result from each input record and the current aggregate value.
• partition assignmentA partition assignment is a mapping of Kafka topic partitions to the consumers responsible for processing them.
• record name strategyRecordNameStrategy is a Schema Registry subject naming strategy that derives a schema subject from the fully qualified record name.
• KeyQueryKeyQuery is a Kafka Streams query that retrieves the result associated with an individual key.
• Query interfaceThe Query interface is the Kafka Streams contract implemented by objects that describe state-store queries.
• QueryResultStateQueryResult is a Kafka Streams response object containing the results of a state-store query by partition.
• SourceTaskA SourceTask is a Kafka Connect task type that polls an external system and returns records for insertion into Kafka.
• KeyValueMapperKeyValueMapper is a Kafka Streams functional interface for mapping an input record's key and value to a new key-value pair.
• data streamAn event stream is a continuous flow of independent records in which records sharing a key are not updates to one another.
• sensor readingA sensor reading is a measurement record produced by an IoT sensor, such as a temperature or proximity observation.
• schema evolutionSchema evolution is the controlled modification of a data schema while preserving compatibility for existing producers, consumers, or stored records.
• @EnableKafkaStreams@EnableKafkaStreams is a Spring annotation that enables Kafka Streams support and lifecycle management for Kafka Streams applications.
• Kafka brokerA Kafka broker is a server process that stores Kafka records and handles requests from Kafka clients and consumers.
• KafkaAvroSerializerKafkaAvroSerializer is a Kafka serializer that encodes Avro records and communicates with Schema Registry to obtain their schemas.
• oneOfoneOf is a Protocol Buffers field construct that permits a message to contain one member from a set of alternative fields.
• GenericRecordA generic record is a schema-aware data container whose fields are accessed dynamically without a generated type-specific class.
• StreamPartitionerA StreamPartitioner is a Kafka Streams component that determines the partition for an output record.
• keyA key is a common identifier used to associate, store, and retrieve a value for a particular record or entity.
• in-memory databaseAn in-memory state store keeps its contents in process memory and loses them when the application shuts down.
• application.serverapplication.server is a Kafka Streams configuration that identifies the host and port where an application instance exposes query access.
• where clauseA WHERE clause is an SQL query clause that restricts returned records to those satisfying a Boolean condition.
• specific recordA specific record is a generated, strongly typed data object whose fields and accessors correspond to a known schema.
• topic record name strategyTopicRecordNameStrategy is a schema subject naming strategy that derives subjects from both the topic name and the record schema, isolating schemas by topic.
• asynchronous programmingAsynchronous processing handles work independently of the caller so the caller does not wait for processing completion.
• automatic offset commitAutomatic offset commit is a consumer behavior that periodically records the offsets associated with consumed records without an explicit commit call.
• manual offset commitA manual offset commit is an explicit operation that persists consumer offsets at an application-chosen point.
• pipelinePipelining is a processing pattern that overlaps record retrieval and record processing so the consumer can continue retrieving batches while earlier batches are handled.
• peekKStream.peek is a Kafka Streams operation that performs a stateless action on each record without changing the record's key or value.
• toKStream.to is a Kafka Streams operation that writes stream records to a Kafka topic through a sink node.
• min.insync.replicasmin.insync.replicas is a Kafka topic configuration specifying the minimum number of in-sync replicas required for a write to succeed.
• KafkaStreamsCustomizerKafkaStreamsCustomizer is a Spring Kafka callback component that customizes a KafkaStreams instance before it starts.
• @PostConstructPostConstruct is a lifecycle annotation that marks a method to be invoked after an object has been constructed and its dependencies injected.
• predestroy annotationPreDestroy is a lifecycle annotation that marks a method to be invoked before a managed object is destroyed.
• StreamsBuilderFactoryBeanStreamsBuilderFactoryBean is a Spring Kafka factory bean that creates a StreamsBuilder and manages the startup and shutdown of a Kafka Streams application.
• StreamsBuilderFactoryBeanCustomizerStreamsBuilderFactoryBeanCustomizer is a Spring Kafka callback interface for customizing a StreamsBuilderFactoryBean.
• fetch requestA fetch request is a Kafka client request that asks a broker to return records from a topic partition starting at a specified offset.
• eager bufferingEager buffering is a buffering policy that permits early result emission before a window is final, potentially producing duplicate results.
• barrierA synchronization barrier is a coordination point at which consumers wait for assignment synchronization before processing can resume.
• eager rebalanceEager rebalancing is a Kafka consumer-group rebalance protocol in which all consumers revoke their existing partition assignments before new assignments are distributed.
• group coordinatorA group coordinator is the Kafka broker responsible for managing a consumer group's membership, rebalancing, and committed offsets.
• group leaderA group leader is the elected Kafka consumer-group member that calculates partition assignments and submits them to the group coordinator.
• distributed modeDistributed mode is a Kafka Connect operating mode in which multiple workers coordinate to run connector tasks across a cluster.
• JDBC connectorA JDBC connector is a Kafka Connect connector that reads from or writes to databases through the Java Database Connectivity interface.
• Kafka Connect workerA Connect worker is a Kafka Connect process that runs connector instances and their tasks.
• standalone modeStandalone mode is a Kafka Connect operating mode in which a single worker runs connectors and their tasks.
• transformA Kafka Connect transform is a record-level operation that changes records as they pass through a connector.
• update streamAn update stream is a continuous flow of records in which a record sharing a key with an earlier record represents an update to that record.
• bootstrap serverbootstrap.servers is the Kafka client configuration containing one or more broker hostname-and-port endpoints used to establish an initial cluster connection.
• backward compatibilityBackward compatibility is the ability of a newer software component or data schema to work with data produced using an older schema or interface.
• tumbling windowA tumbling window is a fixed-duration, non-overlapping stream-processing window whose boundaries advance by the full window duration.
• union typeA union type is a construct whose value or field may conform to one of several specified types.
• ProcessorSupplierProcessorSupplier is a Kafka Streams interface that creates processor instances and can declare state stores associated with them.
• groupByKeygroupByKey is a Kafka Streams stream operation that groups records by their existing keys for subsequent aggregation or other key-based processing.
• KafkaHeadersKafkaHeaders is a Spring Kafka constants class defining header names for Kafka record metadata.
• setConcurrencysetConcurrency is a listener-container-factory method that sets the number of concurrent listener containers or consumer threads.
• KStream.splitKStream.split is a Kafka Streams DSL method that begins branching a KStream and returns a BranchedKStream.
• subjectA subject name is a Schema Registry identifier that groups schema versions governing a particular stream key or value.
• administrative APIAdminClient is Kafka's abstract administrative client class for performing operations on cluster resources.
• repartition topicA repartition topic is an intermediate Kafka topic that temporarily receives records so they can be redistributed according to their updated keys.
• fluent interfaceA fluent interface is an API design pattern in which methods return objects that allow successive operations to be chained in a readable expression.
• KStream.mergeKStream.merge is a Kafka Streams DSL operator that combines multiple KStreams into one stream without guaranteeing ordering across input streams.
• KeyValueStoreKeyValueStore is the Kafka Streams state-store interface for persistently storing and retrieving key-value records.
• ConsumedConsumed is a Kafka Streams configuration object that specifies input serializers and deserializers and other settings for a source node.
• follower nodeA secondary node is a non-leader Schema Registry node that serves reads and forwards schema write requests to the primary node.
• TestcontainersTestcontainers is a library for running disposable containerized dependencies during automated tests and managing their lifecycle.
• transactional producerA transactional producer is a Kafka producer mode that publishes records to multiple topics as one atomic transaction, committing all records together or none of them.
• stream branchingA stream branch is a substream produced by routing records from a parent stream according to a branching condition.
• dereferencing syntaxDereferencing syntax is expression notation for accessing a nested field or element through an enclosing structured value.
• case statementA CASE statement is a SQL conditional expression that evaluates conditions and returns a corresponding result.
• hierarchyA nested structure is a hierarchical data structure whose fields or elements can themselves contain structured values.
• RESTA REST API is an HTTP-based interface that exposes resources and operations through conventional web representations and methods.
• hopping windowA hopping window is a fixed-size time window whose successive windows may overlap because they advance by an interval smaller than their size.
• stream-global-table joinA stream-global-table join combines records from a KStream with matching records in a fully replicated GlobalKTable.
• component decorator@Component is a Spring annotation marking a class for automatic detection and registration as a managed component.
• @KafkaHandler@KafkaHandler is a Spring Kafka annotation that marks a method for dispatching records by the type of their values.
• KafkaListenerContainerA KafkaListenerContainer is a Spring Kafka runtime component that manages a Kafka consumer and invokes listener code for consumed records.
• KafkaTemplate#sendKafkaTemplate#send is a Spring Kafka method that asynchronously sends a key and value to a specified Kafka topic.
• message-driven pojoA message-driven POJO is an ordinary Java object whose methods receive messages through framework configuration rather than Kafka-specific inheritance.
• strict bufferingStrict buffering is a buffering policy that enforces a configured record or byte limit and shuts down the application when the limit is exceeded.
• schema versionA schema version is an ordered revision number identifying one version of a schema under a Schema Registry subject.
• ProducedProduced is a Kafka Streams configuration object that specifies output serializers and deserializers and other settings for a sink node.
• foreign keyA foreign key is a field whose value references a key in another table or record set.
• JoinWindowsA join window is a time interval that determines which records from two streams are eligible to be joined based on their timestamps.
• session windowSessionWindows is a Kafka Streams class that defines session windows separated by an inactivity gap.
• EmitStrategyEmitStrategy is a Kafka Streams configuration API that specifies when results from a windowed operation are emitted.
• BranchedBranched is a Kafka Streams definition that specifies naming and processing behavior for a stream branch.
• BranchedKStreamBranchedKStream is a Kafka Streams object that defines and terminates branches created from a KStream.
• BranchedKStream.branchBranchedKStream.branch is a Kafka Streams method that creates a branch by applying a predicate and branch-processing definition to records.
• default branchA default branch is a fallback stream branch that receives records matching none of the specified predicates.
• ConfigDefConfigDef is a Kafka Connect API class that defines the names, types, defaults, and validation rules for connector configurations.
• network throttlingThrottling is the deliberate limitation of request or operation frequency by delaying execution between attempts.
• source offsetA source offset is a position identifier for a record within an external source partition.
• source partitionA source partition is a logical description of the portion or location of an external system from which a connector obtains data.
• SourceRecordSourceRecord is the Kafka Connect API type representing a record imported from an external source, including source position metadata and optional schemas.
• timestamp extractorA TimestampExtractor is a Kafka Streams component that determines an event timestamp from an input record.
• high-water markA high-water mark is the greatest partition offset replicated to all in-sync replicas and made accessible to consumers.
• KafkaContainerKafkaContainer is a Testcontainers component that provisions and manages a Kafka broker in a Docker container for tests.
• @TestcontainersThe @Testcontainers annotation is a Testcontainers JUnit Jupiter extension that manages container lifecycles declared in a test class.
• log compactionLog compaction is Kafka's process of removing older records for a key while retaining the most recent record for that key.
• subtopologyA sub-topology is a portion of a Kafka Streams topology containing a source node and every processor downstream of that source.
• Gradle pluginA Gradle plugin is an extension that adds project configuration, tasks, or integrations to the Gradle build system.
• stateState is retained information representing the accumulated condition or progress of a stream-processing computation.
• code generationCode generation is the automated production of source code or programming-language objects from formal specifications such as schemas.
• replication factorA replication factor is the configured number of broker replicas maintained for each Kafka topic partition.
• KGroupedTableKGroupedTable is a Kafka Streams abstraction representing a KTable grouped by a key and ready for grouped-table operations.
• sliding windowA sliding window is a fixed-duration stream-processing window whose boundaries are determined by record timestamps and whose contents change as records enter or leave.
• subject name strategyA subject name strategy is a rule that determines how Schema Registry subject names are derived and therefore where compatibility is checked.
• data-driven aggregationA data-driven aggregation is an aggregation whose membership and completion are determined by attributes or conditions in the incoming records rather than fixed time windows.
• data-driven windowingData-driven windowing is the technique of defining a stream window through record values or behavioral conditions instead of predetermined time boundaries.
• event-streaming applicationAn event-streaming application is a software application that produces, consumes, processes, or analyzes event streams.
• real-time processingReal-time processing is the processing of data with sufficiently low delay to support decisions while events are occurring.
• compacted topicA compacted topic is a Kafka topic whose log retains the latest record for each key rather than retaining every historical record indefinitely.
• log segmentA Kafka log segment is a file-backed portion of a partition's append-only log that contains a contiguous range of records along with its indexes.
• out-of-order eventsAn out-of-order record is a record whose timestamp does not follow the timestamp order of records already processed.
• serializationSerialization is the process of converting structured data into a representation suitable for storage or transmission.
• metadataMetadata is information describing the current state, configuration, membership, and permissions of a Kafka cluster.
• filteringfilter is a Kafka Streams operation that retains records satisfying a predicate and emits deletion markers for records removed from a table result.
• use.latest.versionuse.latest.version is a serializer configuration that selects the latest schema version registered for a subject.
• EmitStrategy.onWindowCloseEmitStrategy.onWindowClose is an emit policy that releases a windowed result only when its window closes.
• final windowed resultA final windowed result is the result emitted for a time interval after its window has closed, with no subsequent updates for that interval.
• KTable.suppressKTable.suppress is a Kafka Streams operation that buffers KTable updates and controls their downstream emission.
• TimeWindowsTimeWindows is a Kafka Streams class that defines fixed-size time-based windows with a configurable advance interval.
• SlidingWindowsSlidingWindows is a Kafka Streams class that defines sliding time windows whose boundaries are based on record timestamps.
• application contextA Spring application context is a container-managed registry of application objects and their configuration.
• batchingA batch is a collection of records processed or transmitted together as one unit.
• max.poll.interval.msmax.poll.interval.ms is the maximum allowed time between successful Kafka consumer poll calls before the consumer is considered unresponsive and removed from its group.
• dead letter queueA dead letter queue is a Kafka topic that stores records a connector cannot deliver or process successfully.
• errors.toleranceerrors.tolerance is a Kafka Connect setting that determines whether a connector continues processing after errors.
• ContextualProcessorContextualProcessor is a Kafka Streams base class that supplies processor-context handling while allowing subclasses to override processor lifecycle methods.
• static group membershipStatic membership is a Kafka consumer-group membership mode that assigns each consumer a persistent identity so it can rejoin with its previous partition assignment without an immediate rebalance.
• transform chainA transform chain is an ordered sequence of record transformations in which each transformation receives the preceding transformation's output.
• ExtractFieldExtractField is a Kafka Connect single message transform that extracts one field from a record key or value.
• MaskField SMTMaskField is a Kafka Connect single message transform that replaces selected record fields with configured or type-based replacement values.
• ValueToKeyValueToKey is a Kafka Connect single message transform that copies a field from a record value into the record key.
• standby taskA standby task is a Kafka Streams task that maintains a replicated state-store copy for faster failover when an active task is reassigned.
• Materialized.withCachingDisabled()Materialized.withCachingDisabled() is a Kafka Streams configuration method that disables caching for an individual materialized state store.
• TopicNameExtractorTopicNameExtractor is a Kafka Streams interface whose extraction method determines the destination Kafka topic name for an individual record.
• MockConsumerMockConsumer is a Kafka client test class that simulates a consumer without reading records from a live Kafka broker.
• MockProducerMockProducer is the Kafka client test class that implements Producer behavior without requiring a live Kafka broker.
• key-changing operationA key-changing operation is a stream-processing operation that assigns or derives a different key for records.
• StoreBuilderStoreBuilder is a Kafka Streams builder interface for constructing a state store that can be added directly to a topology.
• printKStream.print is a Kafka Streams terminal operation that prints stream records to an output destination such as the console.
• backing topicA backing topic is the Kafka topic that supplies or persists the records underlying a ksqlDB stream or table.
• base tableA base table is a ksqlDB table created directly from a Kafka topic to expose its keyed records for subsequent queries.
• process methodThe process method is the Processor API method where a processor handles each incoming record and performs its processing logic.
• eventAn event is a record of something that happened, especially business-critical data whose preservation has lasting significance.
• ValueJoinerValueJoiner is a Kafka Streams interface that combines values from matching records in two joined streams into a result value.
• implicit contractAn implicit contract is an unstated agreement about the data structure and representation that communicating software components must share.
• in-sync replicaAn in-sync replica set is the set of Kafka partition replicas that are sufficiently caught up with the partition leader to remain eligible for failover.
• tombstoneA tombstone is a Kafka record with a null value that marks a key for deletion during log compaction.
• PunctuationType.WALL_CLOCK_TIMEPunctuationType.WALL_CLOCK_TIME is a Kafka Streams scheduling mode that triggers punctuation according to the system clock of the Kafka Streams environment.
• system timeSystem time is the current wall-clock value maintained by the machine running a producer or broker.
• inversion of controlInversion of control is a design principle in which a framework or container controls object creation and dependency wiring instead of the application doing so directly.
• change-data-captureChange data capture is a technique for detecting and exporting database record changes such as inserts, updates, and deletes as they occur.
• transaction logA transaction log is an append-only sequence of events or records maintained in occurrence order.
• schedulePollTaskschedulePollTask is a MockConsumer method that queues a task for execution during a subsequent consumer poll.
• SpecificRecordSpecificRecord is an Avro Java interface implemented by generated classes for records with a known schema.
• apply methodThe apply method is the Kafka Connect transformation operation that receives a record and returns its transformed form.
• custom transformationA custom transformation is a user-implemented Kafka Connect record transformation tailored to processing requirements not met by built-in transformations.
• Transformation interfaceThe Kafka Connect Transformation interface defines the contract for components that modify records as they pass through a connector.
• GradleGradle is a build automation tool that defines and executes project tasks, dependency management, and source-generation workflows.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.