github.com/nsqio/nsq

NSQ's Go client is refreshingly straightforward to work with. The basic producer/consumer pattern is intuitive - you create a producer with `nsq.NewProducer()`, publish messages, and set up consumers with handlers. The examples in the repository are clear and get you producing/consuming messages within minutes. Error handling is explicit and follows Go conventions well, though you'll need to handle connection retries yourself in some edge cases.

The consumer API with its `HandleMessage` interface is clean, and the automatic message requeuing on errors is a nice touch. Debugging is generally pleasant - error messages point you in the right direction, and the nsqd logs are verbose enough to trace message flow. One gotcha: the `Config` struct has many fields and some non-obvious defaults (like `MaxInFlight` affecting throughput significantly), so you'll want to read through configuration options carefully.

Community support is decent but not extensive - GitHub issues get responses, though sometimes slowly. Stack Overflow has limited content, so you'll rely more on reading the source code (which is well-organized) and official docs. The lack of complex abstractions means fewer "magic" behaviors to debug, which I appreciate.

NSQ's Go client is a pleasure to work with in production. The Consumer and Producer APIs are straightforward, with sensible defaults that actually work under load. Connection pooling is handled automatically, and the client gracefully manages failover across multiple nsqd instances without manual intervention. The built-in backoff logic when handlers return errors is configurable and works well for transient failures.

Observability is where NSQ really shines - the Stats() method exposes detailed metrics about message rates, in-flight counts, and connection health that integrate cleanly with Prometheus. The logging hooks are comprehensive, though you'll want to wire them to your structured logger immediately since the default output is verbose. Message requeuing semantics are explicit and predictable, which matters when debugging why messages are being retried.

The main gotcha is that MaxInFlight settings interact with concurrency in non-obvious ways - set it too low and you'll underutilize your handlers, too high and you risk overwhelming downstream services. The documentation could be clearer here. Also, graceful shutdown requires careful orchestration of StopChan and draining in-flight messages, but once you have the pattern down it's reliable.

NSQ provides straightforward pub/sub messaging with a simple HTTP/TCP protocol. The Go client libraries are clean and the connection handling is generally reliable. However, from a security perspective, you'll need to invest significant effort in hardening a production deployment.

TLS configuration exists but isn't enforced by default - you must explicitly configure it on both nsqd and clients. The authentication layer (nsqd --auth-http-address) delegates to an external HTTP endpoint, which is flexible but means you're responsible for implementing authn/authz logic correctly. There's no built-in mTLS or certificate validation helpers, so you're writing that boilerplate yourself.

Error messages can leak topology information (node addresses, channel names) which may be sensitive depending on your threat model. Input validation on topic/channel names is basic - the library accepts most strings, so you need application-level validation. The codebase is stable but CVE response has been slow historically, and dependency updates lag behind Go ecosystem best practices.