Packages

case class ProducerImpl[F[_], K, V](p: Producer[K, V])(implicit F: Async[F]) extends ProducerApi[F, K, V] with Product with Serializable

Linear Supertypes
Serializable, Product, Equals, ProducerApi[F, K, V], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ProducerImpl
  2. Serializable
  3. Product
  4. Equals
  5. ProducerApi
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new ProducerImpl(p: Producer[K, V])(implicit F: Async[F])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def abortTransaction: F[Unit]
    Definition Classes
    ProducerImplProducerApi
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def beginTransaction: F[Unit]
    Definition Classes
    ProducerImplProducerApi
  7. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  8. def close(timeout: FiniteDuration): F[Unit]
    Definition Classes
    ProducerImplProducerApi
  9. def close: F[Unit]
    Definition Classes
    ProducerImplProducerApi
  10. def commitTransaction: F[Unit]
    Definition Classes
    ProducerImplProducerApi
  11. final def contrabimap[A, B](f: (A) => K, g: (B) => V): ProducerApi[F, A, B]
    Definition Classes
    ProducerApi
  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  14. def flush: F[Unit]
    Definition Classes
    ProducerImplProducerApi
  15. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. def initTransactions: F[Unit]
    Definition Classes
    ProducerImplProducerApi
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. final def mapK[G[_]](f: ~>[F, G]): ProducerApi[G, K, V]
    Definition Classes
    ProducerApi
  19. def metrics: F[Map[MetricName, Metric]]
    Definition Classes
    ProducerImplProducerApi
  20. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  21. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  22. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  23. val p: Producer[K, V]
  24. def partitionsFor(topic: String): F[Seq[PartitionInfo]]
    Definition Classes
    ProducerImplProducerApi
  25. def productElementNames: Iterator[String]
    Definition Classes
    Product
  26. def sendAndForget(record: ProducerRecord[K, V]): F[Unit]

    The returned F[_] completes as soon as the underlying Producer.send(record) call returns.

    The returned F[_] completes as soon as the underlying Producer.send(record) call returns. This is immediately after the producer enqueues the record, not after Kafka accepts the write. If the producer's internal queue is full, it will block until the record can be enqueued. The returned F[_] will only contain an error if the producer.send(record) call throws an exception. Using this operation, you will not know when Kafka accepts the write, have no way to access the resulting RecordMetadata, and will not know if the write ultimately fails. This allows for the highest write throughput, and is typically OK. You can still use Producer configs to control write behavior, e.g. enable.idempotence, acks, retries, max.in.flight.requests.per.connection, etc. If your program requires confirmation of record persistence before proceeding, you should call sendSync or sendAsync.

    Definition Classes
    ProducerImplProducerApi
  27. def sendAsync(record: ProducerRecord[K, V]): F[RecordMetadata]

    Similar to sendSync, except the returned F[_] is completed asynchronously, usually on the producer's I/O thread.

    Similar to sendSync, except the returned F[_] is completed asynchronously, usually on the producer's I/O thread. TODO does this have different blocking semantics than sendSync?

    Definition Classes
    ProducerImplProducerApi
  28. def sendOffsetsToTransaction(offsets: Map[TopicPartition, OffsetAndMetadata], consumerGroupId: String): F[Unit]
    Definition Classes
    ProducerImplProducerApi
  29. def sendSync(record: ProducerRecord[K, V]): F[RecordMetadata]

    The returned F[_] completes after Kafka accepts the write, and the RecordMetadata is available.

    The returned F[_] completes after Kafka accepts the write, and the RecordMetadata is available. This operation is completely synchronous and blocking: it calls get() on the returned Java Future. The returned F[_] will contain a failure if either the producer.send(record) or the future.get() call throws an exception. You should use this method if your program should not proceed until Kafka accepts the write, or you need to use the RecordMetadata, or you need to explicitly handle any possible error.

    Definition Classes
    ProducerImplProducerApi
  30. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  31. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  32. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  33. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from ProducerApi[F, K, V]

Inherited from AnyRef

Inherited from Any

Ungrouped