raystack/raccoon

Raccoon is an event ingestion service that collects, serializes, and routes events to various backend sinks such as Kafka, Kinesis, and Pub/Sub. It provides a structured Go-based architecture with a command-line interface and supports multiple transport protocols including gRPC, REST, and WebSocket. The system is designed for reliable, graceful lifecycle management and offers client libraries in Go, Java, Python, and JavaScript for sending events.

5 changes.

This period focused on establishing robust release tooling and modernizing the application's lifecycle management. The project introduced structured configuration, automated cross-platform builds, and replaced manual shutdown logic with Go's context-based patterns. Additionally, legacy HTTP endpoints and outdated dependencies were removed or updated across all client libraries.

4 changes.

This period focused on expanding the Raccoon ecosystem by releasing official client libraries for Go, Java, and JavaScript. Each release provided robust, configurable interfaces for sending events via REST, gRPC, and WebSocket transports, significantly broadening the service's accessibility across different programming environments.

5 changes.

This period focused on establishing the core event processing pipeline, introducing a CLI interface, and releasing Python client libraries. It also expanded the system's capabilities by adding new event publishers for various backends and implementing integration tests to validate error handling across multiple protocols.

Introduced a new JavaScript client library for Raccoon, enabling users to send JSON and Protobuf encoded events to the Raccoon server. The client supports configurable serialization types (JSON or Protobuf) and wire types (JSON or Protobuf), with built-in retry mechanisms and configurable timeouts. The package includes a README with usage examples, ESLint and Prettier configurations, and comprehensive test coverage for the client's core functionality.

clients/js · high confidence

A new Python client library for Raccoon is now available, enabling users to send events via REST. The client supports both JSON and Protobuf serialization and wire formats, with configurable retry, timeout, and header settings. Example usage is provided in the \examples\ directory, and the package can be installed from PyPI or directly from the repository.

clients/python · high confidence

The publisher module now includes implementations for four distinct event sinks: a Kafka publisher that handles message production and stats reporting, a Kinesis publisher supporting stream autocreation and mode configuration, a Google Cloud Pub/Sub publisher with topic caching and retention settings, and a Log publisher that writes events to the standard logger. Each publisher implements the standard interface with a Name() method, ProduceBulk() for sending events, and Close() for cleanup, enabling users to route events to these specific backends.

publisher · high confidence

Users can now interact with the Raccoon service using a new Go client library. The library provides three transport implementations—REST, gRPC, and WebSocket—each supporting configurable headers, serializers (JSON or Protocol Buffers), and retry policies. The client also includes a configurable logging interface and a shared \Client\ interface for sending events.

clients/go · high confidence

Added generated Go code for the Raccoon gRPC service, including the \EventService\ client and server interfaces, along with the \SendEvent\ RPC method and associated request/response types (\SendEventRequest\, \SendEventResponse\) and status enums (\Status\, \Code\).

proto · high confidence

The Java client for Raccoon is now available, providing generated Protobuf and gRPC stubs for the \odpf.raccoon.v1beta1\ service. This release includes the \SendEvent\ RPC implementation, allowing Java applications to send events to Raccoon using the \io.odpf.proton.raccoon\ package. The client is built with Gradle and includes configuration for code style checking and proto generation via Buf.

clients/java · high confidence

Users can now interact with the Raccoon application via a new command-line interface. The \cmd/root.go\ file establishes the root 'raccoon' command, while \cmd/server.go\ introduces a 'server' subcommand that starts the Raccoon service, loading configuration and initializing logging and metrics.

cmd · high confidence

Added new packages and files to support event ingestion and processing: a \core/collector\ package defining the \Collector\ interface and a \ChannelCollector\ implementation that pushes \CollectRequest\s to a channel; a \core/worker\ package implementing a \Pool\ of goroutines that consume from that channel and dispatch events to a \Producer\; and \core/serde\ utilities for JSON and Protocol Buffers serialization/deserialization. Additionally, a \pkg/clock\ abstraction for time sources and a \pkg/metrics\ module with Prometheus and StatsD backends were introduced to support instrumentation of the new pipeline.

core, pkg, server · high confidence

The application now uses a structured configuration system that loads settings from environment variables and YAML files. This includes default values for server, publisher, worker, event, metric, and log components. The system validates required fields such as WebSocket connection headers, publisher credentials for PubSub and Kinesis, and Kafka bootstrap servers. It also supports dynamic parsing of Kafka client configurations and allows for flexible publisher types including Kafka, PubSub, Kinesis, and Log. Additionally, the configuration supports CORS headers, Prometheus metrics, and worker buffer settings.

config · high confidence

The Raccoon project now includes comprehensive tooling for building, releasing, and maintaining the codebase. A .golangci.yml file configures Go linting and static analysis, while a .goreleaser.yaml file automates the creation of cross-platform binaries, Docker images, and Linux/macOS packages. Additionally, the Makefile has been reorganized to support these new workflows, and the main entry point has been refactored to use a command-line interface structure.

(repo-wide) · high confidence

The app entry point (app/proc.go) and server initialization (app/server.go) were refactored to use Go's context-based lifecycle management. The previous manual signal handling and blocking shutdown logic were replaced with a structured StartServer function that initializes the HTTP services, publisher, and worker pool, while a dedicated shutdown handler ensures graceful termination by flushing the worker pool with a configurable timeout and closing the publisher. This change improves reliability by preventing data loss during shutdown and aligning the application's lifecycle with standard Go concurrency patterns.

app · medium confidence

The legacy HTTP /ping endpoint and its associated test have been removed from the codebase. This change also eliminates the shared environment variable parsing utilities (AppPort, stringValOrDefault, etc.) that were previously used by the router and handler, as these components are no longer required for the new WebSocket-based communication.

env, handler, router · high confidence

Added a new integration test suite in test/integration/integration\_test.go that validates error handling for invalid requests across WebSocket, gRPC, and HTTP/1.1 REST JSON endpoints, ensuring the system returns appropriate Bad Request responses for malformed or empty payloads.

test · high confidence

The project has updated dependency manifests and build configurations for its client libraries. The Go client (clients/go) now uses Go 1.21/1.22.4 with updated gRPC, protobuf, and linting dependencies. The Java client (clients/java) is configured with Gradle 5.0.0, Lombok, and updated gRPC/Protobuf dependencies. The Python client (clients/python) specifies Python 3.9+ with updated requests, protobuf, and google packages. The JavaScript client (clients/js) and its examples have been updated with axios, protobufjs, and uuid dependencies. The main Go module (go.mod) has been renamed to github.com/raystack/raccoon and upgraded to Go 1.22.4, adding numerous dependencies including AWS SDK, Kafka, Prometheus, Cobra, and gRPC.

(dependencies) · high confidence

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

• CAI 60 → 63 (+3.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 67 → 68 (+1.4)
• Architecture 99 → 77 (-21.3)
• Maturity 69 → 69 (+0.0)
• Readiness 59 → 63 (+3.3)
• Security 53 → 59 (+6.0)

• Boundary-crossing change coupling: publisher.go ↔ client.go (config/publisher.go)
• Change coupling: worker.go ↔ pinger.go (core/worker/worker.go)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (clients/js/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/js/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/js/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/go/go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (12 lines × 2) (clients/go/rest/rest.go)
• Duplicated block (15 lines × 2) (clients/go/examples/grpc/main.go)
• Duplicated block (19 lines × 2) (publisher/kinesis/kinesis.go)
• Duplicated block (8 lines × 2) (clients/go/rest/rest.go)
• High CVE: [GHSA redacted] (clients/js/package-lock.json)
• High CVE: [GHSA redacted] (clients/js/package-lock.json)
• High CVE: [GHSA redacted] (clients/js/package-lock.json)
• High CVE: [GHSA redacted] (clients/js/package-lock.json)
• High CVE: [GHSA redacted] (clients/js/package-lock.json)
• High CVE: [GHSA redacted] (clients/js/package-lock.json)
• …and 42 more

• Coverage not measured — JavaScript/TypeScript suite
• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (clients/js/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/js/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/js/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/go/go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Dependency pinned to a stale untagged commit: github.com/alecthomas/assert
• Dependency pinned to a stale untagged commit: golang.org/x/lint
• Deprecated module: cloud.google.com/go/pubsub
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (clients/go/rest/rest.go)
• Duplicated block (12 lines × 2) (clients/go/rest/rest.go)
• Duplicated block (14–16 lines × 3) (clients/go/examples/grpc/main.go)
• Duplicated block (18 lines × 2) (publisher/kinesis/kinesis.go)
• Duplicated block (24 lines × 2) (clients/go/examples/grpc/main.go)
• Duplicated block (5 lines × 2) (server/rest/handler.go)
• Duplicated block (5 lines × 2) (server/rest/handler.go)
• Duplicated block (7 lines × 2) (clients/go/serializer/serializer.go)
• High CVE: [GHSA redacted] (clients/js/package-lock.json)
• …and 148 more

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

raystack/raccoon 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.