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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:01:21.281Z (3 days ago)
• Versions: 83
• 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:01:21.586Z (3 days ago)
• Versions: 83
• 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:03:55.063Z (3 days ago)
• Versions: 83
• 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:02:44.049Z (3 days ago)
• Versions: 83
• 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:03:52.298Z (3 days ago)
• Versions: 83
• 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:01:23.354Z (3 days ago)
• Versions: 83
• 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:01:51.082Z (3 days ago)
• Versions: 83
• 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/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 7 days ago)
• Last Synced: 2026-03-27T10:01:20.185Z (3 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:04:04.970Z (3 days ago)
• Versions: 83
• 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 2 months ago)
• Last Synced: 2026-03-27T10:03:45.759Z (3 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/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: v0.0.0-20260320155225-3a0f0a4c0c50 (published 10 days ago)
• Last Synced: 2026-03-27T10:01:20.337Z (3 days ago)
• Versions: 4
• 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/interceptors

• Homepage: https://github.com/IBM/sarama
• Documentation: https://pkg.go.dev/github.com/IBM/sarama/examples/interceptors#section-documentation
• Licenses: mit
• Latest release: v0.0.0-20260318212104-f184ee409fc8 (published 11 days ago)
• Last Synced: 2026-03-27T10:03:00.276Z (3 days ago)
• Versions: 7
• 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.47.0 (published about 1 month ago)
• Last Synced: 2026-03-27T10:03:05.590Z (3 days ago)
• Versions: 83
• 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: v0.0.0-20260312132609-87a9321440fc (published 18 days ago)
• Last Synced: 2026-03-27T10:02:25.197Z (3 days ago)
• Versions: 4
• 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-03-27T10:03:52.647Z (3 days ago)
• Versions: 26
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 9.115%
  • Average: 9.696%
  • Dependent repos count: 10.278%

ubuntu-24.10: golang-github-ibm-sarama

• Homepage: https://github.com/IBM/sarama
• Licenses:
• Latest release: 1.43.2-1 (published about 2 months ago)
• Last Synced: 2026-03-08T15:44:54.801Z (22 days ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%

debian-13: golang-github-ibm-sarama

• Homepage: https://github.com/IBM/sarama
• Documentation: https://packages.debian.org/trixie/golang-github-ibm-sarama
• Licenses:
• Latest release: 1.45.1-1 (published about 2 months ago)
• Last Synced: 2026-03-13T19:14:35.407Z (17 days ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%