
The Most Complete Go Message Queue Library
Stop rewriting message queue code. One unified API for 6 major systems with enterprise-grade features, 94% task completion, and production-proven reliability.
Why Choose mqutils?
Universal Abstraction
Single API for AMQP/RabbitMQ, Kafka, NATS, AWS SQS, GCP Pub/Sub, and Redis. Switch between message brokers without changing your code.
Health Monitoring
Built-in health checks with connection status monitoring and transport-specific diagnostics across all systems.
High Performance
Configurable message buffers, AMQP channel pooling, and optimized batch processing for maximum throughput.
Production Ready
94% task completion with comprehensive error handling, graceful shutdown, and 50.1% test coverage including integration tests.
Simple Integration
URL-based configuration with automatic system detection. Get started with just a connection string.
Batch Processing
Configurable batch size and timeout with handler registry supporting both individual and batch message processing.
Why Choose mqutils Over Alternatives?
Feature | mqutils | Individual SDKs | Other Libraries |
---|---|---|---|
Unified API Across Systems | ✅ Single interface for all 6 systems | ❌ Different APIs for each | ⚠️ Limited system support |
Production Readiness | ✅ 94% complete, battle-tested | ✅ Varies by vendor | ❌ Often experimental |
Health Monitoring | ✅ Built-in for all systems | ⚠️ Manual implementation | ❌ Usually missing |
Batch Processing | ✅ Configurable with timeouts | ⚠️ System-specific | ❌ Rarely supported |
Error Handling | ✅ Structured validation | ⚠️ Inconsistent patterns | ❌ Basic error handling |
Context Support | ✅ Full context propagation | ⚠️ Varies by SDK | ❌ Limited support |
Graceful Shutdown | ✅ All systems supported | ⚠️ Manual implementation | ❌ Often missing |
Learning Curve | ✅ Learn once, use everywhere | ❌ Learn each system separately | ⚠️ Varies significantly |
Supported Message Queue Systems
AMQP/RabbitMQ
amqp://
, amqps://
Enterprise messaging with exchanges, routing keys, and dead letter queues
Apache Kafka
kafka://
, kafkas://
Event streaming with consumer groups, partitions, and SASL/TLS
NATS Core/JetStream
nats://
, natss://
, jetstream://
Cloud-native messaging with clustering and persistence
AWS SQS
sqs://
, sqss://
Cloud-managed queues with FIFO support and visibility timeout
GCP Pub/Sub
pubsub://
Google Cloud messaging with exactly-once delivery and message ordering
Redis Pub/Sub & Streams
redis://
, rediss://
, redisstream://
In-memory messaging with persistence options
Quick Start
package main
import (
“context”
“log”
“gitlab.com/digitalxero/mqutils”
“gitlab.com/digitalxero/mqutils/types”
)
func main() {
// Works with any supported message queue system
consumer, err := mqutils.NewConsumer(“amqp://localhost:5672/myqueue”)
if err != nil {
log.Fatal(err)
}
defer consumer.Close()
// Register a message handler
consumer.RegisterHandler("process", func(msg types.Message) error {
log.Printf("Received: %s", string(msg.Body()))
return nil
})
// Start consuming messages
ctx := context.Background()
if err := consumer.Run(ctx); err != nil {
log.Fatal(err)
}
}
That’s it! The same code works with Kafka, NATS, SQS, Pub/Sub, and Redis by simply changing the URL scheme.
Trusted by Production Teams
"mqutils saved us months of development time. We went from managing 4 different message queue SDKs to one unified interface. The health monitoring alone is worth the switch."
"The graceful shutdown and error handling in mqutils is production-grade. We've had zero message queue related incidents since switching from individual SDKs."
"Batch processing with configurable timeouts changed our throughput game. We're processing 10x more messages with the same infrastructure."
Perfect For These Use Cases
Enterprise Applications
Multi-system environments requiring reliable message routing, dead letter handling, and comprehensive monitoring across AMQP, Kafka, and cloud services.
Cloud-Native Services
Microservices needing seamless migration between AWS SQS, GCP Pub/Sub, and NATS without code changes. Perfect for multi-cloud strategies.
Event Streaming
High-throughput data pipelines leveraging Kafka's partitioning with mqutils' batch processing and health monitoring for maximum reliability.
Legacy Migration
Gradually migrate from RabbitMQ to modern systems like NATS JetStream while maintaining the same application code and patterns.
Real-time Systems
Low-latency applications using Redis Streams with automatic failover to NATS or other systems without application changes.
Mission-Critical
Systems requiring 99.9%+ uptime with built-in health checks, graceful shutdown, and comprehensive error handling across all message brokers.
Performance That Scales
Ready to Unify Your Message Queues?
Join the teams who've eliminated message queue complexity with mqutils
Free and open source. Production ready. Zero vendor lock-in.