go-kit/kit

This system is a modular Go toolkit for building microservices, providing a standardized way to implement authentication, authorization, and observability across various transport protocols. It offers a unified interface for logging, metrics, and distributed tracing, with built-in support for HTTP, gRPC, and message brokers like RabbitMQ and NATS. Additionally, it includes service discovery mechanisms for registries such as Consul, etcd, and ZooKeeper, enabling resilient client-side load balancing and endpoint management.

31 changes.

This period focused on establishing a comprehensive set of distributed systems primitives, including robust service discovery implementations for Consul, ZooKeeper, and Eureka, alongside a new endpoint and transport abstraction layer. The team also expanded the metrics and tracing capabilities to support multiple backends and distributed tracing standards, while refactoring the logging infrastructure to a standalone repository.

20 changes.

This period focused on expanding the library's capabilities by adding support for diverse transport protocols (gRPC, NATS, AMQP, AWS Lambda) and logging backends (syslog, logrus, Zap). It also introduced new metrics exporters for CloudWatch and InfluxData, alongside service discovery implementations for etcd and internal caching mechanisms.

The \transport/amqp\ package introduces a new transport layer for interacting with AMQP 0-9-1 message brokers, specifically targeting RabbitMQ. This addition provides \Publisher\ and \Subscriber\ components that implement the \endpoint.Endpoint\ interface, allowing services to send and receive messages via AMQP. The implementation includes request/response encoding and decoding functions, context-based configuration for exchange, routing keys, and delivery modes, along with comprehensive test coverage for error handling and successful message flows.

transport/amqp · high confidence

The transport/awslambda package introduces a new transport layer for AWS Lambda, providing a Handler that wraps a go-kit endpoint to handle incoming Lambda payloads. It includes encode/decode functions for request and response mapping, along with support for pre/post-processing via HandlerBefore and HandlerAfter functions, and configurable error handling and finalizers.

transport/awslambda · high confidence

A new Basic Authentication middleware is now available in the auth/basic package. It validates the username and password from the HTTP request's Authorization header against provided credentials, returning a 401 Unauthorized error for invalid or missing credentials. The implementation uses constant-time comparison to prevent timing attacks and includes a README with usage examples.

auth/basic · high confidence

A new authorization middleware has been added to the application, integrating the Casbin library (v2) to enforce access control policies. This change introduces a middleware that validates whether a subject is authorized to perform a specific action on a given object, using a configurable access control model and policy. The implementation includes the middleware logic, associated context keys, and test data files to support the new authorization flow.

auth/casbin · high confidence

Users can now send metrics to AWS CloudWatch using the new CloudWatch backend. This implementation supports counters, gauges, and histograms (including configurable percentiles), and includes a WriteLoop helper for periodic reporting. The API allows configuration of concurrent request limits and custom loggers, with tests verifying correct dimension and value handling.

metrics/cloudwatch · high confidence

Introduces a new CloudWatch v2 metrics exporter in the \metrics/cloudwatch2\ package, enabling users to send aggregated metric data to Amazon CloudWatch using the AWS SDK for Go v2. The implementation supports counters, gauges, and histograms by emitting a \StatisticsSet\ per metric, with configurable concurrency limits and optional logging for error handling.

metrics/cloudwatch2 · high confidence

The sd/dnssrv package introduces a new Instancer that resolves DNS SRV records to discover service instances. It supports configurable refresh intervals and allows custom lookup functions. The implementation includes error handling for invalid SRV records (specifically those with port 0) and provides a Stop method to cleanly terminate the background resolution loop.

sd/dnssrv · high confidence

The \sd/eureka\ package now provides an \Instancer\ and \Registrar\ for interacting with Netflix's Eureka service registry. The \Instancer\ watches for changes in a specific application's instances and updates subscribers, while the \Registrar\ manages instance liveness by performing periodic heartbeats and handling re-registration on expiration. The implementation includes unit tests (\instancer\_test.go\, \registrar\_test.go\) and an integration test (\integration\_test.go\) that validates the lifecycle of registering, updating, and deregistering instances against a live Eureka server.

sd/etcd, sd/eureka · high confidence

A new \metrics/graphite\ package is introduced, providing a backend for sending metrics to a Graphite server using the plaintext protocol. The implementation supports counters, gauges, and histograms (reported as per-quantile gauges), with batched writes and helper methods (\WriteLoop\, \SendLoop\) for regular reporting. Tests are included to verify the behavior of all three metric types.

(repo-wide) · high confidence

The transport/httprp package introduces a new HTTP reverse-proxy transport that forwards requests to a specified upstream service. Users can now instantiate a proxying server and attach multiple 'ServerBefore' hooks to modify the HTTP request before it is proxied, enabling global request transformations without per-handler configuration.

transport/httprp · high confidence

Added a new InfluxDB metrics implementation in the \metrics/influx\ package, providing support for counters, gauges, and histograms. The implementation includes the core \influx.go\ logic for collecting and flushing metric data, along with corresponding unit tests in \influx\_test.go\ and example tests in \example\_test.go\ to verify behavior.

metrics/influx · high confidence

Introduces a new \influxstatsd\ package that provides support for InfluxData's StatsD Telegraf plugin, allowing metrics to be batched and emitted to a remote server. The implementation supports counters, gauges, timings, and histograms with arbitrary tags per metric, and includes helper methods (\WriteLoop\, \SendLoop\) for regular reporting. The change also includes the corresponding test suite for these new metrics types.

metrics/influxstatsd · high confidence

Introduces a new JSON-RPC transport implementation for HTTP, providing both client and server components. Users can now build JSON-RPC services by defining an EndpointCodecMap to route methods to endpoints, with support for custom request/response encoding and decoding, middleware hooks (before/after/finalizer), and structured error handling that preserves request IDs and error codes in responses.

transport/http/jsonrpc · high confidence

The NATS transport implementation is now available, providing Publisher and Subscriber components for sending and receiving messages via NATS. Users can configure encoding and decoding functions, apply request and response middleware, and handle errors through customizable encoders and handlers.

transport/nats · high confidence

Introduces OpenCensus-based tracing middleware for HTTP, gRPC, and JSON-RPC transports, as well as for Go kit endpoints. This allows users to instrument their services with distributed tracing spans, supporting custom span names, attribute injection, error status reporting, and trace context propagation across HTTP, gRPC, and JSON-RPC boundaries.

tracing/opencensus · high confidence

Users can now report metrics to the Performance Co-Pilot (PCP) system via a new \metrics/pcp\ package. This addition introduces a \Reporter\ that wraps the \performancecopilot/speed\ library to provide \Counter\, \Gauge\, and \Histogram\ implementations compatible with the \go-kit/metrics\ interface. The \Histogram\ specifically supports metric units and includes tests for all three metric types.

metrics/pcp · high confidence

The transport/http/proto package now provides EncodeProtoRequest and EncodeProtoResponse functions, enabling HTTP services to serialize requests and responses as Protobuf messages. This allows clients and servers to exchange data in the application/x-protobuf format, with support for custom headers and HTTP status codes.

transport/http/proto · high confidence

The metrics package now includes a Timer struct that acts as a stopwatch, automatically calculating the elapsed time since its creation and forwarding the observation to a wrapped Histogram. This provides a convenient syntax sugar for recording durations, with support for custom time units (e.g., seconds, milliseconds) and configurable tolerance in tests. The addition includes the Timer implementation, its unit-setting method, and corresponding tests.

metrics · high confidence

Users can now bridge Go kit's logging interface to Uber's Zap library via a new \NewZapSugarLogger\ adapter in the \log/zap\ package. This allows applications using Go kit's \log.Logger\ interface to seamlessly route log events to a Zap logger, with support for all standard log levels (Debug through Fatal) and corresponding panic behavior. A comprehensive test suite validates that key-value pairs and log levels are correctly translated to JSON output.

log/zap · high confidence

Introduces three new circuit breaker implementations for the go-kit endpoint middleware: Gobreaker, HandyBreaker, and Hystrix. Each provides a middleware that wraps an endpoint to prevent thundering herds and improve resiliency against intermittent errors. The entry includes the corresponding test files for each implementation.

circuitbreaker · high confidence

The sd/lb package now provides a client-side load balancing interface with implementations for random and round-robin selection strategies, along with a retry wrapper that automatically retries failed requests up to a specified limit or timeout. Users can now integrate this package to distribute traffic across service instances without relying on external load balancers.

sd/lb · high confidence

The \sd/etcdv3\ package introduces a new implementation for service discovery using the etcd v3 API. This includes a \Client\ interface and its concrete implementation for interacting with etcd v3, an \Instancer\ to watch for service changes, and a \Registrar\ to handle service registration and deregistration with optional TTL-based lease management. The package also provides example code demonstrating how to use the client, registrar, and instancer together for service registration and discovery.

sd/etcdv3 · high confidence

The \metrics/generic\ package introduces in-memory implementations for Counter, Gauge, and Histogram metrics. The Counter and Gauge types use atomic operations for thread-safe updates, while the Histogram wraps \VividCortex/gohistogram\ with a mutex for goroutine safety. This provides a baseline, dependency-light way to track metrics in memory, with tests verifying atomic alignment and concurrent access.

metrics/generic · high confidence

The log/level package is introduced to provide leveled logging on top of the standard log package. Users can now wrap their loggers with level.NewFilter to control which log levels (Debug, Info, Warn, Error) are passed through or squelched, and use helper functions like level.Debug or level.Info to emit log events at specific levels. This adds a new capability for controlling log verbosity and structure in applications.

log/level · high confidence

Users can now use the logrus library as a backend for the go-kit logging interface. A new \log/logrus\ package provides a \Logger\ implementation that wraps a \logrus.FieldLogger\, allowing applications to route logs through logrus while maintaining compatibility with the standard \go-kit/log.Logger\ interface. The adapter supports configuring the minimum logging level via the \WithLevel\ option, ensuring that only messages at or above the specified severity are processed.

log/logrus · high confidence

The metrics/provider package introduces a Provider interface and concrete implementations for Discard, Dogstatsd, Expvar, Graphite, Influx, Prometheus, and StatsD. This allows users to swap out metrics backends dynamically at runtime by selecting the appropriate provider, rather than hardcoding a single metrics implementation. Each provider implements the Provider interface, which abstracts over constructors and lifecycle management for the respective backend.

metrics/provider · high confidence

The metrics/multi package now provides Counter, Gauge, and Histogram adapters that forward observations to multiple underlying metric instances simultaneously. This allows services to emit metrics to multiple instrumentation systems at once, such as during a transition between monitoring backends. The implementation includes NewCounter, NewGauge, and NewHistogram constructors, along with With methods that propagate label values to all wrapped metrics.

metrics/multi · high confidence

The library now includes a syslog logger implementation, allowing users to send log messages to the system's syslog daemon. This new capability is exposed via the \log/syslog\ package, which provides a \NewSyslogLogger\ function to create loggers that write to a \SyslogWriter\ with configurable priority selection.

log/syslog · high confidence

The ratelimit package now includes token bucket rate limiting via NewErroringLimiter and NewDelayingLimiter, which wrap go-kit endpoints to either reject requests that exceed the rate limit or delay them accordingly. The implementation leverages golang.org/x/time/rate and provides adapter functions (AllowerFunc, WaiterFunc) to simplify integration with the rate limiter.

ratelimit · high confidence

The transport package now provides a standardized way to handle errors across all supported transports. A new \ErrorHandler\ interface and a \LogErrorHandler\ implementation have been added, allowing users to configure how transport-level errors are processed, with logging as the default behavior.

transport · high confidence

Added the \util/conn\ package, which provides a \Manager\ for handling network connections with automatic reconnection and exponential backoff. The \Manager\ allows clients to safely acquire and release connections, automatically retrying on failure. A corresponding test suite verifies the reconnection logic, including handling of initial dial failures and transient errors.

util · high confidence

Added README.md and doc.go files for the tracing package, providing an overview of request tracing capabilities and documentation for supported backends including Zipkin, OpenCensus, OpenTracing, and OpenTelemetry.

tracing · high confidence

A new internal cache implementation has been added to manage service discovery state. This cache stores the latest set of instances and notifies all registered listeners when updates occur, ensuring each observer receives a copy of the event data to prevent data races. The implementation includes a Stop method and supports the push model for service discovery.

sd/internal · high confidence

Added new internal packages to support metrics functionality: \metrics/internal/convert\ provides adapters to convert between Counter, Histogram, and Gauge types; \metrics/internal/lv\ introduces a \Space\ for managing N-dimensional time series data and a \LabelValues\ helper for label handling; \metrics/internal/ratemap\ adds a thread-safe map for tracking metric sample rates. These components provide the internal foundation for metric collection and conversion.

metrics/internal · high confidence

A new 'discard' package has been added to provide a no-op implementation of the metrics interface. This allows users to disable metrics collection by using this backend, which implements Counter, Gauge, and Histogram interfaces with empty methods, effectively ignoring all metrics data.

metrics/discard · high confidence

The \metrics/teststat\ package was added, introducing new utilities for testing metrics backends. This includes \TestCounter\, \TestGauge\, and \TestHistogram\ functions to verify metric values, as well as \PopulateNormalHistogram\ for generating test data. Additionally, \SumLines\, \LastLine\, and \Quantiles\ helpers were added to parse and analyze metric output from writers.

metrics/teststat · high confidence

The HTTP transport layer is now available in the \transport/http\ package, providing \Client\ and \Server\ wrappers for endpoints. The client supports configurable request and response functions, finalizers, and buffered streams, while the server supports request/response hooks, custom error encoding, and finalizers. This includes new types like \interceptingWriter\ to capture response headers and status codes for finalizers, and utility functions like \EncodeJSONRequest\ and \PopulateRequestContext\.

transport/http · high confidence

The \auth/jwt\ package now provides a complete JWT authentication solution, including \NewParser\ and \NewSigner\ middleware functions for validating and generating tokens, along with transport helpers (\HTTPToContext\, \ContextToHTTP\, \GRPCToContext\, \ContextToGRPC\) to automatically inject and extract JWTs from HTTP and gRPC headers. The implementation uses the \github.com/golang-jwt/jwt/v4\ library and supports custom claims factories for flexible token parsing.

auth/jwt · high confidence

The log/term package now provides colorized logging capabilities. Users can create a color logger that applies ANSI color codes to log output based on message content or log level, using the new NewColorLogger and NewColorWriter functions. Additionally, the package exposes terminal detection and color constants to help format logs with distinct colors for errors, warnings, and other levels, improving readability in terminal environments.

log/term · medium confidence

The endpoint package is introduced to provide a fundamental abstraction for RPCs, defining the Endpoint type as a function signature for single RPC methods. This includes a Nop endpoint for testing, a Middleware type for chainable behavior modification, and a Chain helper for composing middlewares. Additionally, a Failer interface is provided to allow response types to expose business logic errors.

endpoint · high confidence

Adds a new gRPC transport implementation for go-kit, providing client and server handlers that wrap endpoints to handle gRPC requests and responses. The change includes the core client and server logic, encode/decode functions, and request/response function hooks (before/after) for both client and server sides. A README file is also added to document the integration of gRPC with go-kit, including instructions for setting up the protoc compiler and generating Go code from .proto files. A test file is included to verify the client's functionality.

transport/grpc · high confidence

The \tracing/zipkin\ package now provides native OpenZipkin tracing middleware for Go kit HTTP, gRPC, and endpoint transports. This update introduces new middleware functions (\HTTPClientTrace\, \HTTPServerTrace\, \GRPCClientTrace\, \GRPCServerTrace\, and \TraceEndpoint\) that integrate with the \zipkin-go\ library to automatically capture and report distributed traces. The implementation includes support for span context propagation, configurable span naming, custom tags, and request-based sampling, enabling users to monitor and debug distributed systems with full Zipkin compatibility.

tracing/zipkin · high confidence

Added a new implementation of service discovery for HashiCorp Consul, including an Instancer that polls Consul for service instances, a Registrar for registering service liveness, and a Client wrapper for the Consul API. The Instancer handles index-based polling, tag filtering, and error handling (including EOF recovery), while the Registrar manages service registration and deregistration. Tests cover instancer behavior, tag filtering, address overrides, and integration with a live Consul instance.

sd/consul · high confidence

The \tracing/opentracing\ package now provides first-class support for distributed tracing via the OpenTracing standard. Users can wrap endpoints with \TraceEndpoint\, \TraceServer\, and \TraceClient\ middlewares that automatically create and manage spans. The package also includes \ContextToHTTP\/\HTTPToContext\ and \ContextToGRPC\/\GRPCToContext\ request functions to inject and extract trace context from HTTP headers and gRPC metadata. This allows for consistent tracing across HTTP and gRPC transport layers.

tracing/opentracing · high confidence

The sd/zk package now provides a complete service discovery implementation for ZooKeeper, including a Client interface, an Instancer that watches for path changes, and a Registrar for publishing service liveness. The Client wraps the go-zookeeper/zk library, supporting configurable ACLs, credentials, and timeouts, while the Instancer updates subscribers when instances change. Tests cover client configuration, instancer updates, and integration scenarios.

sd/zk · high confidence

The service discovery package has been refactored to support a push-based update model, where an Instancer pushes complete sets of instance updates to subscribers. A new endpointCache component caches endpoints and manages their lifecycle, allowing the Endpointer to continue returning the last known endpoints even when the service discovery system reports an error, unless the InvalidateOnError option is enabled to trigger a timeout-based invalidation. This change introduces the core interfaces (Instancer, Endpointer, Registrar) and their default implementations to decouple service discovery from the endpoint creation and caching logic.

sd · medium confidence

The leveled logging wrapper from the kit/log package has been moved to a new 'deprecated\_levels' subpackage. This change relocates the existing leveled logging functionality to a deprecated location, signaling that users should migrate to the standard library's logging capabilities. The move includes both the implementation and its associated tests, ensuring the deprecated API remains functional while encouraging adoption of modern logging practices.

_log/deprecated\levels · medium confidence

The repository now includes a \.gitignore\ file to exclude compiled objects, temporary files, and IDE artifacts, alongside a \lint\ script to automate static analysis and code quality checks. A \docker-compose-integration.yml\ file is added to standardize local integration test environments for services like etcd, Consul, and ZooKeeper. Additionally, \contributing.md\ and \codecov.yml\ are introduced to formalize the process for external contributors and configure code coverage reporting.

(repo-wide) · high confidence

The \log\ package and its subpackages (\log/level\, \log/term\, \log/syslog\) have been moved to a separate repository at \github.com/go-kit/log\. The existing \log\ package in this repository now acts as a compatibility layer, aliasing types and functions to the new repository. Users are encouraged to migrate their imports to \github.com/go-kit/log\ for future updates, though the current package remains functional for backward compatibility.

log · high confidence

A new internal test package (\transport/grpc/\_grpc\_test\) was added to verify gRPC transport behavior, specifically focusing on the propagation of headers and trailers between client and server. The suite includes generated protobuf definitions and helper functions that demonstrate how request/response functions can be used to inject, display, and extract metadata (such as correlation IDs) across the gRPC boundary.

_transport/grpc/\_grpc\test · high confidence

The project introduces a go.mod file, establishing Go modules for the first time and defining the module path as github.com/go-kit/kit with Go 1.17. This change includes the addition of numerous direct and indirect dependencies, such as AWS SDKs, Casbin, NATS, and various logging and tracing libraries, effectively initializing the project's dependency graph.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 52 → 49 (-3.4)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 89 → 92 (+3.4)
• Architecture 100 → 91 (-9.2)
• Maturity 41 → 30 (-10.8)
• Readiness 53 → 51 (-2.6)
• Security 52 → 69 (+17.0)

• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (metrics/internal/lv/space.go)
• Duplicated block (10 lines × 2) (tracing/opencensus/http.go)
• Duplicated block (11 lines × 2) (metrics/dogstatsd/dogstatsd.go)
• Duplicated block (11 lines × 2) (metrics/dogstatsd/dogstatsd.go)
• Duplicated block (11 lines × 2) (sd/etcd/instancer.go)
• Duplicated block (11 lines × 2) (sd/etcd/instancer.go)
• Duplicated block (12 lines × 2) (metrics/dogstatsd/dogstatsd.go)
• Duplicated block (12 lines × 2) (sd/etcd/registrar.go)
• Duplicated block (12 lines × 2) (tracing/opencensus/http.go)
• Duplicated block (13 lines × 2) (metrics/dogstatsd/dogstatsd.go)
• Duplicated block (13 lines × 2) (metrics/dogstatsd/dogstatsd.go)
• Duplicated block (13 lines × 2) (tracing/opencensus/http.go)
• Duplicated block (13 lines × 2) (tracing/opencensus/http.go)
• Duplicated block (13 lines × 2) (tracing/zipkin/grpc.go)
• Duplicated block (16 lines × 2) (tracing/zipkin/grpc.go)
• …and 18 more

• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Dependency pinned to a stale untagged commit: github.com/afex/hystrix-go
• Dependency pinned to a stale untagged commit: github.com/influxdata/influxdb1-client
• Dependency pinned to a stale untagged commit: github.com/streadway/handy
• Dependency pinned to a stale untagged commit: golang.org/x/sync
• Dependency pinned to a stale untagged commit: golang.org/x/time
• Deprecated module: github.com/aws/aws-sdk-go
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (metrics/dogstatsd/dogstatsd.go)
• Duplicated block (10 lines × 2) (metrics/influxstatsd/influxstatsd.go)
• Duplicated block (12 lines × 2) (metrics/cloudwatch/cloudwatch.go)
• Duplicated block (12 lines × 2) (metrics/dogstatsd/dogstatsd.go)
• Duplicated block (12 lines × 2) (sd/etcd/registrar.go)
• Duplicated block (12 lines × 2) (tracing/opencensus/http.go)
• Duplicated block (12 lines × 2) (tracing/zipkin/grpc.go)
• Duplicated block (12 lines × 4) (metrics/dogstatsd/dogstatsd.go)
• …and 76 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

go-kit/kit was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.