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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:21.576Z (1 day ago)
• Versions: 79
• 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

• Homepage:
• Documentation: https://pkg.go.dev/github.com/ibm/Sarama#section-documentation
• Licenses: mit
• Latest release: v1.46.0 (published 12 days ago)
• Last Synced: 2025-09-04T11:04:38.780Z (2 days ago)
• Versions: 50
• 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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:30.067Z (1 day ago)
• Versions: 79
• 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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:31.963Z (1 day ago)
• Versions: 79
• 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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:30.371Z (1 day ago)
• Versions: 79
• 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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:32.159Z (1 day ago)
• Versions: 79
• 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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:30.720Z (1 day ago)
• Versions: 79
• 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 1 day ago)
• Last Synced: 2025-09-05T06:41:56.321Z (1 day 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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:31.442Z (1 day ago)
• Versions: 79
• 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 9 days ago)
• Last Synced: 2025-08-28T02:36:31.324Z (9 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 15 days ago)
• Last Synced: 2025-08-21T23:35:41.388Z (15 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/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 8 days ago)
• Last Synced: 2025-08-29T03:05:00.926Z (8 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.0 (published 12 days ago)
• Last Synced: 2025-09-05T06:42:31.687Z (1 day ago)
• Versions: 79
• 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 30 days ago)
• Last Synced: 2025-08-07T16:48:37.984Z (30 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 over 1 year ago)
• Last Synced: 2025-08-28T02:35:35.498Z (9 days ago)
• Versions: 26
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 9.115%
  • Average: 9.696%
  • Dependent repos count: 10.278%