FinagleKafkaConsumer

Instance Constructors

new FinagleKafkaConsumer(config: FinagleKafkaConsumerConfig[K, V])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def assign(partitions: Seq[TopicPartition]): Unit

Manually assign partitions to the consumer.
Manually assign partitions to the consumer. This assignment is not incremental but replaces the previous assignment.
def assignment(): Future[Set[TopicPartition]]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(deadline: Time): Future[Unit]

Definition Classes
FinagleKafkaConsumer → Closable
def close(after: Duration): Future[Unit]

Definition Classes
Closable
final def close(): Future[Unit]

Definition Classes
Closable
def commit(offsets: Map[TopicPartition, OffsetAndMetadata]): Future[Unit]

Commit the specified offsets for the specified list of topics and partitions.
def commit(): Future[Unit]

Commit offsets returned on the last poll() for all the subscribed list of topics and partition.
def debug(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def debug(message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def debug(marker: Marker, message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def debug(message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def debugFutureResult[T](msg: String)(func: ⇒ Future[T]): Future[T]

Attributes
protected
Definition Classes
Logging
def debugResult[T](message: ⇒ String)(fn: ⇒ T): T

Attributes
protected[this]
Definition Classes
Logging
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def error(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def error(message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def error(marker: Marker, message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def error(message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def errorResult[T](message: ⇒ String)(fn: ⇒ T): T

Attributes
protected[this]
Definition Classes
Logging
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def info(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def info(message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def info(marker: Marker, message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def info(message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def infoResult[T](message: ⇒ String)(fn: ⇒ T): T

Attributes
protected[this]
Definition Classes
Logging
def isDebugEnabled(marker: Marker): Boolean

Attributes
protected[this]
Definition Classes
Logging
def isDebugEnabled: Boolean

Attributes
protected[this]
Definition Classes
Logging
def isErrorEnabled(marker: Marker): Boolean

Attributes
protected[this]
Definition Classes
Logging
def isErrorEnabled: Boolean

Attributes
protected[this]
Definition Classes
Logging
def isInfoEnabled(marker: Marker): Boolean

Attributes
protected[this]
Definition Classes
Logging
def isInfoEnabled: Boolean

Attributes
protected[this]
Definition Classes
Logging
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTraceEnabled(marker: Marker): Boolean

Attributes
protected[this]
Definition Classes
Logging
def isTraceEnabled: Boolean

Attributes
protected[this]
Definition Classes
Logging
def isWarnEnabled(marker: Marker): Boolean

Attributes
protected[this]
Definition Classes
Logging
def isWarnEnabled: Boolean

Attributes
protected[this]
Definition Classes
Logging
final def logger: Logger

Attributes
protected[this]
Definition Classes
Logging
final def loggerName: String

Attributes
protected[this]
Definition Classes
Logging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def offsetsForTimes(timestampsToSearch: Map[TopicPartition, Long]): Future[Map[TopicPartition, OffsetAndTimestamp]]
def poll(timeout: Duration = config.pollTimeout): Future[ConsumerRecords[K, V]]

timeout
The time, in milliseconds, spent waiting in poll if data is not available in the buffer. If 0, returns immediately with any records that are available currently in the buffer, else returns empty. Must not be negative.
returns
map of topic to records since the last fetch for the subscribed list of topics and partitions
def position(partition: TopicPartition): Future[Long]

Get the offset of the next record that will be fetched (if a record with that offset exists).
def seekToBeginning(partitions: Collection[TopicPartition]): Future[Unit]
def seekToEnd(partitions: Collection[TopicPartition]): Future[Unit]
def seekToOffset(partition: TopicPartition, offset: Long): Future[Unit]
def subscribe(topics: Set[KafkaTopic], listener: Option[ConsumerRebalanceListener] = None): Unit

Subscribe to the given list of topics to get dynamically assigned partitions.
Subscribe to the given list of topics to get dynamically assigned partitions.
We block start until the consumer is subscribed to the topic. We're using a future pool here since Kafka requires all interactions with the consumer to come from a single thread.
final def synchronized[T0](arg0: ⇒ T0): T0

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

Attributes
protected
Definition Classes
Logging
def toString(): String

Definition Classes
AnyRef → Any
def trace(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def trace(message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def trace(marker: Marker, message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def trace(message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def traceResult[T](message: ⇒ String)(fn: ⇒ T): T

Attributes
protected[this]
Definition Classes
Logging
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def wakeup(): Unit

Wakeup the consumer.
Wakeup the consumer. This method is thread-safe and is useful in particular to abort a long poll.
The thread which is blocking in an operation will throw WakeupException If no thread is blocking, the next blocking call will raise it instead.
def warn(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def warn(message: ⇒ Any, cause: Throwable): Unit

Attributes
protected[this]
Definition Classes
Logging
def warn(marker: Marker, message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def warn(message: ⇒ Any): Unit

Attributes
protected[this]
Definition Classes
Logging
def warnResult[T](message: ⇒ String)(fn: ⇒ T): T

Attributes
protected[this]
Definition Classes
Logging

Related Doc: package consumers

class FinagleKafkaConsumer[K, V] extends Closable with Logging

Instance Constructors

new FinagleKafkaConsumer(config: FinagleKafkaConsumerConfig[K, V])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def assign(partitions: Seq[TopicPartition]): Unit

def assignment(): Future[Set[TopicPartition]]

def clone(): AnyRef

def close(deadline: Time): Future[Unit]

def close(after: Duration): Future[Unit]

final def close(): Future[Unit]

def commit(offsets: Map[TopicPartition, OffsetAndMetadata]): Future[Unit]

def commit(): Future[Unit]

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): 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 finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

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 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

final def logger: Logger

final def loggerName: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def offsetsForTimes(timestampsToSearch: Map[TopicPartition, Long]): Future[Map[TopicPartition, OffsetAndTimestamp]]

def poll(timeout: Duration = config.pollTimeout): Future[ConsumerRecords[K, V]]

def position(partition: TopicPartition): Future[Long]

def seekToBeginning(partitions: Collection[TopicPartition]): Future[Unit]

def seekToEnd(partitions: Collection[TopicPartition]): Future[Unit]

def seekToOffset(partition: TopicPartition, offset: Long): Future[Unit]

def subscribe(topics: Set[KafkaTopic], listener: Option[ConsumerRebalanceListener] = None): Unit

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

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

def toString(): String

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wakeup(): 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

Inherited from Logging