AsyncStreamKafkaConsumerBuilder

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val asyncStreamConsumerConfig: AsyncStreamKafkaConsumerConfig[K, V]

def autoCommitInterval(duration: Duration): This

def autoOffsetReset(offsetResetStrategy: OffsetResetStrategy): This

def bootstrapServers(servers: String): This

def buildClient(): KafkaConsumer[K, V]

Create the native KafkaConsumer client.

def checkCrcs(boolean: Boolean): This

def clientId(clientId: String): This

def clone(): AnyRef

def config: FinagleKafkaConsumerConfig[K, V]

The KafkaConsumerConfig config, which can be used to build KafkaConsumer

def configMap: Map[String, String]

def connectionsMaxIdle(duration: Duration): This

def debug(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def debug(message: ⇒ Any, cause: Throwable): Unit

def debug(marker: Marker, message: ⇒ Any): Unit

def debug(message: ⇒ Any): Unit

def debugFutureResult[T](msg: String)(func: ⇒ Future[T]): Future[T]

def debugResult[T](message: ⇒ String)(fn: ⇒ T): T

def dest(dest: String, timeout: Duration): This

Configure the Kafka server the consumer will connect to.

def dest(dest: String): This

Configure the Kafka server the consumer will connect to.

def enableAutoCommit(boolean: Boolean): This

final def eq(arg0: AnyRef): Boolean

def error(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def error(message: ⇒ Any, cause: Throwable): Unit

def error(marker: Marker, message: ⇒ Any): Unit

def error(message: ⇒ Any): Unit

def errorResult[T](message: ⇒ String)(fn: ⇒ T): T

def excludeInternalTopics(boolean: Boolean): This

def fetchMax(storageUnit: StorageUnit): This

def fetchMaxWait(duration: Duration): This

def fetchMin(storageUnit: StorageUnit): This

def finalize(): Unit

def fromConfigMap(configMap: Map[String, String]): This

Override this in your concrete builder with a copy constructor for that builder that replaces the old configMap with a modified one.

def fromFinagleConsumerConfig(config: FinagleKafkaConsumerConfig[K, V]): This

final def getClass(): Class[_]

def groupId(groupId: KafkaGroupId): This

def heartbeatInterval(duration: Duration): This

def includeNodeMetrics(include: Boolean): This

For KafkaFinagleMetricsReporter: whether to include node-level metrics.

def info(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def info(message: ⇒ Any, cause: Throwable): Unit

def info(marker: Marker, message: ⇒ Any): Unit

def info(message: ⇒ Any): Unit

def infoResult[T](message: ⇒ String)(fn: ⇒ T): T

def interceptor[T](implicit arg0: Manifest[T]): This

def isDebugEnabled(marker: Marker): Boolean

def isDebugEnabled: Boolean

def isErrorEnabled(marker: Marker): Boolean

def isErrorEnabled: Boolean

def isInfoEnabled(marker: Marker): Boolean

def isInfoEnabled: Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(marker: Marker): Boolean

def isTraceEnabled: Boolean

def isWarnEnabled(marker: Marker): Boolean

def isWarnEnabled: Boolean

def isolationLevel(isolationLevel: IsolationLevel): This

def keyDeserializer(keyDeserializer: Deserializer[K]): This

Deserializer class for key

final def logger: Logger

final def loggerName: String

def maxPartitionFetch(storageUnit: StorageUnit): This

def maxPollInterval(duration: Duration): This

def maxPollRecords(int: Int): This

def metadataMaxAge(duration: Duration): This

def metricReporter[T](implicit arg0: Manifest[T]): This

def metricsNumSamples(int: Int): This

def metricsRecordingLevel(recordingLevel: RecordingLevel): This

def metricsSampleWindow(duration: Duration): This

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def partitionAssignmentStrategy[T](implicit arg0: Manifest[T]): This

def pollTimeout(pollTimeout: Duration): This

Default poll timeout in milliseconds

def receiveBuffer(storageUnit: StorageUnit): This

def reconnectBackoff(duration: Duration): This

def reconnectBackoffMax(duration: Duration): This

def requestTimeout(duration: Duration): This

def retryBackoff(duration: Duration): This

def rewindDuration(rewindDuration: Duration): This

If using SeekStrategy.REWIND, specify the duration back in time to rewind and start consuming from

def seekStrategy(seekStrategy: SeekStrategy): This

Whether the consumer should start from end, beginning or from the offset

def sendBufferConfig(storageUnit: StorageUnit): This

def sessionTimeout(duration: Duration): This

def subscribe(): ClosableAsyncStream[ConsumerRecord[K, V]]

final def synchronized[T0](arg0: ⇒ T0): T0

def time[T](formatStr: String)(func: ⇒ T): T

def topics(topics: Set[KafkaTopic]): This

def trace(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def trace(message: ⇒ Any, cause: Throwable): Unit

def trace(marker: Marker, message: ⇒ Any): Unit

def trace(message: ⇒ Any): Unit

def traceResult[T](message: ⇒ String)(fn: ⇒ T): T

def validateConfigs(config: FinagleKafkaConsumerConfig[K, V]): Unit

def valueDeserializer(valueDeserializer: Deserializer[V]): This

Deserializer class for value

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def warn(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def warn(message: ⇒ Any, cause: Throwable): Unit

def warn(marker: Marker, message: ⇒ Any): Unit

def warn(message: ⇒ Any): Unit

def warnResult[T](message: ⇒ String)(fn: ⇒ T): T

def withClassName[T](key: String)(implicit arg0: Manifest[T]): This

def withClassNameBuilder[T](key: String)(implicit arg0: Manifest[T]): This

def withConfig(keyValuesMap: Map[String, String]): This

def withConfig(key: String, value: StorageUnit): This

def withConfig(key: String, value: Duration): This

def withConfig(key: String, value: Boolean): This

def withConfig(key: String, value: Int): This

def withConfig(key: String, value: String): This

def build(): FinagleKafkaConsumer[K, V]