proxy.golang.org: github.com/IBM/sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use Consumer or Consumer-Group API. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics: Consumer related metrics:

• Homepage: https://github.com/IBM/sarama
• Documentation: https://pkg.go.dev/github.com/IBM/sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:04.899Z (4 days ago)
• Versions: 82
• Dependent Packages: 195
• Dependent Repositories: 6
• Docker Downloads: 2,360,422,712
• Rankings:
  • Forks count: 0.581%
  • Stargazers count: 0.621%
  • Docker downloads count: 1.848%
  • Dependent repos count: 2.128%
  • Average: 2.726%
  • Dependent packages count: 8.453%

proxy.golang.org: github.com/ibm/Sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/ibm/Sarama
• Documentation: https://pkg.go.dev/github.com/ibm/Sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:01.463Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.747%
  • Stargazers count: 0.752%
  • Average: 3.062%
  • Dependent packages count: 5.199%
  • Dependent repos count: 5.548%

proxy.golang.org: github.com/IBM/SARAMA

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/IBM/SARAMA
• Documentation: https://pkg.go.dev/github.com/IBM/SARAMA#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:04.312Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.58%
  • Stargazers count: 0.619%
  • Average: 5.011%
  • Dependent packages count: 8.453%
  • Dependent repos count: 10.392%

proxy.golang.org: github.com/Ibm/sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/Ibm/sarama
• Documentation: https://pkg.go.dev/github.com/Ibm/sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:26:36.102Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.582%
  • Stargazers count: 0.621%
  • Average: 5.167%
  • Dependent packages count: 8.899%
  • Dependent repos count: 10.567%

proxy.golang.org: github.com/IBM/Sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/IBM/Sarama
• Documentation: https://pkg.go.dev/github.com/IBM/Sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:04.150Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.582%
  • Stargazers count: 0.621%
  • Average: 5.167%
  • Dependent packages count: 8.899%
  • Dependent repos count: 10.567%

proxy.golang.org: github.com/ibm/sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/ibm/sarama
• Documentation: https://pkg.go.dev/github.com/ibm/sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:00.949Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Docker Downloads: 33,478,147
• Rankings:
  • Forks count: 0.582%
  • Stargazers count: 0.621%
  • Average: 5.167%
  • Dependent packages count: 8.899%
  • Dependent repos count: 10.567%

proxy.golang.org: github.com/IBm/sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/IBm/sarama
• Documentation: https://pkg.go.dev/github.com/IBm/sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:03.896Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.582%
  • Stargazers count: 0.621%
  • Average: 5.167%
  • Dependent packages count: 8.899%
  • Dependent repos count: 10.567%

proxy.golang.org: github.com/IBM/sarama/examples/sasl_scram_client

• Homepage: https://github.com/IBM/sarama
• Documentation: https://pkg.go.dev/github.com/IBM/sarama/examples/sasl_scram_client#section-documentation
• Licenses: mit
• Latest release: (published 4 days ago)
• Last Synced: 2026-02-03T22:27:05.131Z (4 days ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.571%
  • Stargazers count: 0.611%
  • Average: 5.39%
  • Dependent packages count: 9.576%
  • Dependent repos count: 10.802%

proxy.golang.org: github.com/IbM/sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/IbM/sarama
• Documentation: https://pkg.go.dev/github.com/IbM/sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:08.745Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.572%
  • Stargazers count: 0.612%
  • Average: 5.39%
  • Dependent packages count: 9.576%
  • Dependent repos count: 10.802%

proxy.golang.org: github.com/IBM/sarama/examples/http_server

• Homepage: https://github.com/IBM/sarama
• Documentation: https://pkg.go.dev/github.com/IBM/sarama/examples/http_server#section-documentation
• Licenses: mit
• Latest release: (published 11 days ago)
• Last Synced: 2026-01-27T09:56:20.846Z (11 days ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 5.792%
  • Average: 5.986%
  • Dependent repos count: 6.18%

proxy.golang.org: github.com/IBM/sarama/examples/interceptors

• Homepage: https://github.com/IBM/sarama
• Documentation: https://pkg.go.dev/github.com/IBM/sarama/examples/interceptors#section-documentation
• Licenses: mit
• Latest release: (published 4 months ago)
• Last Synced: 2025-10-23T06:03:50.521Z (4 months ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 5.882%
  • Average: 6.079%
  • Dependent repos count: 6.276%

proxy.golang.org: github.com/IBM/sarama/examples/txn_producer

• Homepage: https://github.com/IBM/sarama
• Documentation: https://pkg.go.dev/github.com/IBM/sarama/examples/txn_producer#section-documentation
• Licenses: mit
• Latest release: (published 4 days ago)
• Last Synced: 2026-02-03T22:27:01.504Z (4 days ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 5.882%
  • Average: 6.079%
  • Dependent repos count: 6.276%

proxy.golang.org: github.com/iBM/sarama

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. For lower-level needs, the Broker and Request/Response objects permit precise control over each connection and message sent on the wire; the Client provides higher-level metadata management that is shared between the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up exactly with the protocol fields documented by Kafka at https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. Broker related metrics: Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. Producer related metrics:

• Homepage: https://github.com/iBM/sarama
• Documentation: https://pkg.go.dev/github.com/iBM/sarama#section-documentation
• Licenses: MIT
• Latest release: v1.46.3 (published 3 months ago)
• Last Synced: 2026-02-03T22:27:10.733Z (4 days ago)
• Versions: 82
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 6.325%
  • Average: 6.538%
  • Dependent repos count: 6.751%

proxy.golang.org: github.com/IBM/sarama/examples/exactly_once

• Homepage: https://github.com/IBM/sarama
• Documentation: https://pkg.go.dev/github.com/IBM/sarama/examples/exactly_once#section-documentation
• Licenses: mit
• Latest release: (published 15 days ago)
• Last Synced: 2026-01-23T07:44:39.164Z (15 days ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 6.334%
  • Average: 6.548%
  • Dependent repos count: 6.762%

proxy.golang.org: github.com/ibm/sarama/examples/http_server

• Homepage: https://github.com/ibm/sarama
• Documentation: https://pkg.go.dev/github.com/ibm/sarama/examples/http_server#section-documentation
• Licenses: MIT
• Latest release: v1.20.1 (published about 2 years ago)
• Last Synced: 2026-01-28T08:44:07.330Z (10 days ago)
• Versions: 26
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 9.115%
  • Average: 9.696%
  • Dependent repos count: 10.278%