Accenture/reactive-interaction-gateway

The Reactive Interaction Gateway (RIG) is a high-performance event routing and distribution platform that ingests CloudEvents from diverse transport protocols including HTTP, Kafka, AWS Kinesis, and NATS. It provides real-time event delivery to clients via WebSocket, Server-Sent Events, and long-polling, while simultaneously supporting reverse-proxy functionality to forward requests to backend services. The system features modular authorization, distributed tracing, and comprehensive monitoring capabilities, all managed through a centralized configuration and API.

22 changes.

This period focused on establishing the core RIG architecture, including centralized configuration, distributed session management, and Kafka integration. The team also built out the 'channels' example application to demonstrate the system's capabilities, while simultaneously expanding test coverage and documentation to support the new features.

32 changes.

This period focused on building out the Inbound Gateway's capabilities to support multiple transport protocols, including Kafka, Kinesis, and NATS, alongside enhanced authentication and event filtering. The work introduced a new API v3, expanded real-time connection handling for SSE, WebSocket, and long-polling, and added comprehensive test coverage for these new features.

7 changes.

This period focused on enhancing system observability by adding metrics, dashboards, and distributed tracing for CloudEvents and HTTP requests. It also expanded the platform's capabilities through new v3 API endpoints for proxy management and event publishing, alongside integration and performance tests for NATS, WebSocket, and SSE connections.

The kinesis-client module now includes Java classes (App, ErlangInterface, RecordProcessor, RecordProcessorFactory, RunnableKinesis) that connect to an Amazon Kinesis stream and forward records to a RIG Erlang node via the OTP interface. The application reads environment variables (RIG\_ERLANG\_NAME, RIG\_ERLANG\_COOKIE, KINESIS\_APP\_NAME, KINESIS\_AWS\_REGION, KINESIS\_STREAM, KINESIS\_ENDPOINT, KINESIS\_DYNAMODB\_ENDPOINT) to configure the Kinesis Client Library worker and the Erlang connection. Logging is configurable via the LOG\_LEVEL environment variable, and checkpointing is performed on shard termination.

kinesis-client/src · high confidence

New performance test scripts have been added to the artillery directory, enabling load testing for both WebSocket and Server-Sent Events (SSE) connections. The configuration targets localhost:4000 and simulates 4,500 connections per minute, maintaining each connection for 15 seconds. The tests measure connection establishment times for both protocols using Artillery's ws and sse engines.

_performance\tests · high confidence

New example projects have been added to demonstrate the API Gateway's capabilities. The HTTP example provides a basic proxy configuration and a simple Node.js service to act as a backend. The Kafka example includes a Docker Compose setup for running a local Kafka broker, along with configuration files and documentation showing how to send CloudEvents to Kafka, including a note about current trace context forwarding limitations.

examples/api-gateway · high confidence

Introduced new modules for handling JSON and JWT-based subscription parsing, alongside utilities for reading request bodies and parsing HTTP authorization headers. The \RIG.JWT\ module now supports parsing and validating JSON Web Tokens, while \RIG.Subscriptions.Parser\ provides logic to decode subscriptions from both JSON payloads and JWT claims. Additionally, \RIG.Plug\ includes new plugs for extracting authentication tokens from headers and reading full request bodies, enabling more robust authentication and request processing capabilities.

(repo-wide) · high confidence

The channels example now includes a React-based frontend application. This adds the main application component, entry point, CSS styling, and a service worker for offline caching. It also configures a development proxy to forward requests to the backend at localhost:7000 with WebSocket support, enabling the example to function as a complete, runnable demo.

examples/channels-example/frontend/src · high confidence

The \guides\ directory now includes a set of Architecture Decision Records (ADRs) that document key architectural choices, including the use of \adr-tools\, testing strategies for pattern matching, configuration management via \Rig.Config\, and the preference for prefix-based configuration keys. Additionally, new system overview diagrams (\.graphml\, \.svg\, and \.xml\ files) have been added to visualize the architecture and component relationships.

guides · high confidence

The channels example now includes a complete, runnable demonstration of the Reactive Interaction Gateway (RIG) integration. The service layer is a Node.js/Hapi REST API that produces messages to Kafka, while the frontend is a React application that connects via WebSockets or Server-Sent Events (SSE) to consume events. The example is fully containerized with Dockerfiles for both the frontend and the service, and includes configuration files (nginx, .gitignore, ESLint) to support local development and production deployment.

examples/channels-example/service · high confidence

The channels example now includes a complete setup for demonstrating Reactive Interaction Gateway (RIG) with Kafka and UI components. This update adds Jaeger integration for distributed tracing, allowing users to trace requests and events across the system. The example also includes Docker Compose configurations and scripts to easily spin up the environment, including Kafka, Zookeeper, RIG, an external service, and a frontend UI.

examples/channels-example · high confidence

A new \Rig.Connection.Codec\ module was added to handle the encoding and decoding of connection tokens, such as PIDs, using AES-GCM encryption. This component provides \serialize\ and \deserialize\ functions that encrypt data with a configurable secret key, ensuring that the resulting string is URL-safe. The change includes comprehensive property-based tests verifying that serialization and deserialization are inverse operations and that encryption/decryption works correctly across various key types and lengths.

lib/rig/connection · high confidence

The system now supports distributed tracing for CloudEvents and HTTP requests. A new module, RIG.Tracing.CloudEvent, provides a macro for creating spans from CloudEvent headers (traceparent/tracestate), and a new RIG.Tracing.Plug module handles HTTP request and response headers for OpenCensus integration.

lib/rig/tracing · high confidence

Users can now monitor metrics for events, subscriptions, and blacklists via Prometheus and Grafana. The change introduces a new monitoring setup in the \monitoring/metrics\ directory, including a Docker Compose configuration that spins up Prometheus, Grafana, Kafka, and other services. It also adds a script (\run.sh\) to start the environment and generate test events, along with configuration files for Prometheus scraping and Grafana dashboards.

monitoring/metrics · high confidence

A new smoke test suite has been added to validate the integration between the Reactive Interaction Gateway (RIG) and external backend services, specifically supporting both plaintext and SSL-encrypted connections to Kafka. The update includes a Docker Compose configuration that spins up Zookeeper, Kafka (with both PLAIN and SSL listeners), and a REST API simulation service. The test script automatically waits for Kafka readiness, generates the necessary SSL certificates and keystores, and executes tests against both unencrypted and password-protected SSL endpoints to ensure secure communication.

_smoke\tests · high confidence

The lib/rig\_kafka area now includes new modules for Avro serialization and deserialization (lib/rig\_kafka/avro.ex), a Kafka client implementation (lib/rig\_kafka/client.ex) that manages broker connections and message processing, a configuration struct (lib/rig\_kafka/config.ex) for Kafka settings, and a serializer interface (lib/rig\_kafka/serializer.ex) that routes between Avro and other formats. These changes introduce support for Avro-encoded messages via a schema registry and provide the underlying client and configuration structures required for Kafka communication.

_lib/rig\kafka · high confidence

The Channels example now includes the frontend React components (Channels, Events, and Message) that provide the user interface for connecting to and interacting with message channels. These components enable users to select transport protocols (WebSocket or Server-Sent Events), manage subscriptions, view event logs, and send messages to Kafka, demonstrating the full client-side integration for the channels example.

examples/channels-example/frontend/src/components · high confidence

New modules in lib/rig\_metrics now expose Prometheus metrics and Telemetry hooks for tracking event consumption/production, subscription counts, proxy request counts, and distributed set sizes. This enables monitoring these system components via Prometheus and visualizing them in tools like Grafana or Phoenix LiveDashboard.

_lib/rig\metrics · high confidence

A new Node.js application has been added to the smoke\_tests/rest-api directory, providing a REST API with endpoints for handling HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS) and a Kafka message producer. The application includes a Dockerfile for containerization, a .gitignore file, and source files for the main server, API routes, and Kafka integration.

_smoke\tests/rest-api · high confidence

A new Elixir-based utility script has been added to the scripts directory to generate JSON Web Tokens (JWTs) for testing purposes. The script accepts parameters such as secret, user, roles, and expiration time, allowing developers to easily create signed JWTs compatible with the RIG system.

scripts · high confidence

The system now supports consuming events from Kafka, AWS Kinesis, and NATS message brokers. New modules (KafkaToFilter, KinesisToFilter, NatsToFilter) parse incoming messages into CloudEvents and forward them to the event filter, enabling the platform to ingest events from these additional transport protocols.

_lib/rig/event\stream · high confidence

The examples directory now includes a comprehensive set of long-polling (LP) demo HTML files (lp-1-demo.html, lp-2-demo-simple-extractors.html, lp-3-demo-jwt.html, etc.) that demonstrate connection and subscription workflows for the RIG platform. Additionally, existing Server-Sent Events (SSE) and WebSocket (WS) examples have been updated to align with the latest CloudEvents changes, ensuring consistent behavior across all supported transport protocols.

examples · high confidence

Four new Mix tasks have been added to the project: \compile\_kinesis\_client\ to build the Java-based Kinesis client, \publish\_gh\_pages\ to deploy API reference documentation to the gh-pages branch, \smoke\_tests\ to run Docker-based smoke tests, and \update\_docs\ to update the operator's guide with actual configuration defaults. These tasks automate key parts of the build, testing, and documentation workflows.

lib/mix · high confidence

The \priv\ directory now includes TLS certificates (\ca.crt.pem\, \client.crt.pem\, \client.key.pem\, and self-signed certificates) and JSON configuration files for the proxy system (\proxy.smoke\_test.json\, \proxy.test.inbound.json\, \proxy.test.json\). These files define the proxy endpoints, authentication types, header transformations, and target URLs for testing and smoke tests.

priv · high confidence

New configuration files (config.exs, dev.exs, prod.exs, test.exs) are added for the RIG API application. These files define the Phoenix endpoint settings, including HTTP/HTTPS ports, SSL certificate paths, and environment-specific overrides. The configuration also sets up the API versioned modules (V1, V2, V3) to use the appropriate proxy implementations (RigInboundGateway.Proxy or Mocks for testing).

_config/rig\api · high confidence

The channels example frontend now includes dedicated utility modules for handling authentication and real-time communication. A new services module provides a function to generate JSON Web Tokens (JWT) using a secret key. Additionally, separate modules implement client-side logic for Server-Sent Events (SSE) and WebSocket connections, each handling connection setup, subscription management, and message listening. These utilities enable the frontend to interact with the backend via both SSE and WebSocket protocols, supporting the example's distributed tracing and event subscription workflows.

examples/channels-example/frontend/src/utils · high confidence

The repository is initialized with essential configuration files including a Credo linter setup, a Dockerfile for building the Elixir application, a .tool-versions file specifying Erlang 23.2.2 and Elixir 1.11.3, and a Travis CI build configuration. The project also includes a Dockerfile for running smoke tests, a vm.args file for Erlang runtime settings, and standard repository files like LICENSE, README, and CODE\_OF\_CONDUCT.

(repo-wide) · high confidence

Added a new \rig\_cloud\_events\ library that provides robust parsing for CloudEvents in both structured and binary modes, supporting CloudEvents specification versions 0.1 and 0.2. The implementation includes a partial parser for efficient handling of large payloads and a full parser for complete data interpretation. Additionally, \PlugUtils\ was added to handle incoming HTTP requests, automatically detecting the CloudEvents mode (structured, batched, or binary) based on content type and headers, and routing the request to the appropriate handler.

_lib/rig\_cloud\events · high confidence

Added new modules for authorization checks: RIG.AuthorizationCheck.External for HTTP-based validation, RIG.AuthorizationCheck.Header for JWT header validation, RIG.AuthorizationCheck.Request for request parsing, and RIG.AuthorizationCheck.Submission and .Subscription for specific event/subscription authorization logic. This refactors the authorization check system into distinct, testable components.

_lib/rig/authorization\check · high confidence

Added new modules to the inbound gateway to support reverse-proxy API definitions. The \RigInboundGateway.Proxy\ module provides a GenServer-based interface for persisting and managing API definitions (create, read, update, replace, deactivate) with eventual consistency across distributed nodes. The \RigInboundGateway.Events\ module introduces utility functions for generating CloudEvents (e.g., connection creation, subscription updates) with OpenCensus tracing context. A new \RigInboundGateway.RequestLogger\ protocol defines the interface for request logging backends.

_lib/rig\_inbound\gateway · high confidence

Added lib/rig/session/connection.ex, a new module that manages the lifecycle of session connections. It provides functions to associate a connection process with a specific session and to terminate all connections associated with a session by broadcasting a kill signal to the relevant processes.

lib/rig/session · high confidence

The project now includes a dedicated documentation website built with Docusaurus. This new site organizes the previously scattered README and source documentation into a structured, navigable format. It includes sections for getting started, main concepts, advanced guides, and production operations. The site features a custom footer with links to documentation, community resources (Slack, Stack Overflow, GitHub), and a user showcase page. Configuration files for the site, including sidebar navigation, localization strings, and site metadata, have been added to support this new documentation hub.

website · high confidence

A new API proxy subsystem has been introduced to the inbound gateway, enabling the routing of incoming HTTP requests to various backend targets including HTTP, Kafka, Kinesis, and NATS. The implementation includes a router that matches requests against configured endpoints, supporting path regex matching and header transformation. The system enforces strict configuration validation (e.g., requiring 'topic' for Kafka targets) and supports authentication checks (JWT) and CORS headers. This change adds the core logic for proxying requests, handling responses, and managing API definitions via Phoenix Presence.

_lib/rig\_inbound\_gateway/api\proxy · high confidence

The event filter module has been replaced with a new implementation that supports configurable field-based event filtering. The system now uses a \Config\ module to validate and manage field configurations, a \Server\ GenServer to manage subscriptions and forward events, and a \SubscriptionMatcher\ to generate ETS match specifications for efficient filtering. Tests have been added to verify the filtering logic, including handling of constraints, wildcard subscriptions, and configuration reloading.

_lib/rig/event\filter · high confidence

The \lib/rig\_inbound\_gateway\_web/v1\ directory now contains new controller and handler modules that expose the inbound gateway's real-time capabilities. \event\_controller.ex\ handles POST requests to publish CloudEvents. \sse.ex\ and \websocket.ex\ implement the Server-Sent Events and WebSocket protocols respectively, managing subscriptions and forwarding events to clients. \longpolling\_controller.ex\ provides a long-polling alternative for clients that cannot maintain persistent connections. \health\_controller.ex\ adds a basic health check endpoint. These changes introduce the core infrastructure for real-time event delivery.

_lib/rig\_inbound\_gateway\web/v1 · high confidence

Added new modules to support request logging via the console and Apache Kafka. The \ConfigValidation\ module enforces configuration requirements, ensuring that Kafka brokers are configured when the Kafka logger is active. The \Console\ module provides a basic logging implementation that prints request details to standard output. The \Kafka\ module implements a full request logger that serializes request data (including IP, path, and tracing context) into CloudEvents format and publishes them to a Kafka topic, supporting both Avro and JSON serialization.

_lib/rig\_inbound\_gateway/request\logger · high confidence

The lib/rig\_api/v3 directory introduces a new set of internal API controllers. The apis.ex module provides a CRUD interface for managing reverse-proxy API definitions, including listing, creating, updating, and deactivating proxy endpoints. The messages.ex module adds a new /v3/messages endpoint that accepts CloudEvents for synchronous forwarding to subscribers. The responses.ex module introduces a /v3/responses endpoint to submit messages to correlated reverse proxy requests. Finally, the session\_blacklist.ex module adds endpoints to blacklist sessions, allowing administrators to invalidate specific sessions for a set duration. These changes are accompanied by comprehensive test coverage in the corresponding \_test.exs files.

_lib/rig\api/v3 · high confidence

The inbound gateway now supports proxying requests to HTTP, Kafka, Kinesis, and NATS targets. This adds new handler modules for each target type, enabling the gateway to forward HTTP requests to these backends and, for asynchronous targets (Kafka, Kinesis, NATS), optionally wait for and return the correlated response. The HTTP handler manages request forwarding and response handling, while the Kafka, Kinesis, and NATS handlers manage producing messages to their respective message brokers and handling the response flow.

_lib/rig\_inbound\_gateway/api\proxy/handler · high confidence

Added new certificate and key files for the Kafka smoke tests, including a CA, client, and server certificates. The private keys are now encrypted (password-protected), addressing a previous issue where keys were not secured.

_smoke\tests/certs · medium confidence

The jinterface.jar artifact (version 1.8.1) from org.erlang.otp has been added to the local Maven repository, including its POM, metadata, and checksum files. This resolves the missing dependency required for the Amazon Kinesis client integration.

kinesis-client/local-maven-repo · medium confidence

The application's configuration has been consolidated into the new \config/config.exs\ file, introducing environment-variable-driven settings for Kafka brokers, SSL, SASL, and consumer topics, alongside NATS server connections, Jaeger/Zipkin tracing endpoints, and connection rate limits. This change also standardizes logger metadata, sets the JSON library to Jason, and configures session and authorization checks, making the system more flexible and easier to deploy across environments.

config · high confidence

The Inbound Gateway is now fully configurable via environment variables and external config files. Users can now control proxy timeouts (HTTP, Kafka, Kinesis), set CORS headers, and configure logging destinations (Console, Kafka) for API requests. The gateway also supports forwarding requests to Kafka topics, Kinesis streams, and NATS topics, with all settings exposed as environment variables (e.g., KAFKA\_BROKERS, CORS, PROXY\_RECV\_TIMEOUT).

_config/rig\_inbound\gateway · high confidence

A new RIG API v2 is introduced, providing a dedicated set of controllers for managing reverse-proxy API definitions, publishing and receiving CloudEvents, and managing session blacklists. This version introduces breaking changes to the session-blacklist functionality and adds new endpoints for listing, creating, updating, and deactivating proxy APIs, as well as new endpoints for submitting events and handling asynchronous responses.

_lib/rig\api/v2 · high confidence

The project has replaced its previous release configuration with a new \rel/config.exs\ file that uses Distillery to define the \:rig\ release. This change introduces pre-configure and post-start hooks, including a script to validate the node host and generate a random node cookie if not provided, ensuring more robust deployment and runtime configuration.

rel · high confidence

The inbound gateway now introduces a dedicated connection initialization flow that validates JWT tokens, checks subscription authorization, and enforces a new rate limit on the number of connections per minute. If a client exceeds this limit, the server returns a 429 error. The change also adds a circular event buffer to store recent events and a session management system that tracks active connections and timeouts. Routing is updated to expose health checks and subscription management endpoints for all three connection types (SSE, WebSocket, long-polling).

_lib/rig\_inbound\_gateway\web · high confidence

The RIG core library is refactored into a set of new modules including \Rig.Application\ for bootstrapping the system, \Rig.Config\ for centralized configuration management, and \Rig.Tracing\ for distributed tracing with Jaeger and Zipkin. The \Rig.DistributedSet\ provides a distributed, time-to-live-backed set for session blacklisting, while \Rig.Session\ manages session lifecycle and blacklisting. Event handling is structured through \Rig.EventFilter\ and \Rig.Subscription\ for matching and routing events. The \Rig.KafkaConfig\ and \Rig.KafkaConsumerSetup\ modules handle Kafka integration, and \Rig.JWT\ manages JSON Web Token parsing and validation. HTTP handling is abstracted in \Rig.Sources.HTTP.Handler\ for CloudEvents. Tests are added for \Rig.DistributedSet\, \Rig.PubSub\, and \Rig.Session\.

lib/rig · high confidence

The Helm charts for the Reactive Interaction Gateway have been updated to version 2.1.3, aligning with the application's new version 3.0.0. This update includes refreshed chart metadata, templates, and default values, ensuring the Kubernetes deployment manifests correctly reflect the latest application version and configuration defaults.

deployment/reactive-interaction-gateway, deployment/reactive-interaction-gateway-helm-v2 · high confidence

The API service has been upgraded to Phoenix 1.5, which includes a switch from the Poison JSON library to Jason. This update introduces a new /v3 internal API endpoint to support response codes, alongside the existing /v2 endpoints. The router now explicitly defines routes for /v2 and /v3, each exposing APIs, messages, responses, and session-blacklist functionality. Additionally, the health check endpoint is now exposed at /health, and the Phoenix Live Dashboard is integrated at /dashboard for monitoring.

_lib/rig\api · medium confidence

Add integration test for consuming from a NATS topic; Added Cypress integration tests for channels and subscription scenarios; Added Cypress test support files for UI automation; Added Cypress-based functional tests for examples; Added comprehensive test coverage for RIG components; Added integration tests for Avro message encoding and decoding; Added integration tests for Kafka-based request logging; Added integration tests for publishing events to Kafka via the reverse proxy; Added test support modules for proxy configuration and client testing; Added tests for Avro encoding/decoding, serializer prefix handling, and network outage scenarios; Added tests for RIG configuration parsing and subscription handling; Added tests for health check, metrics, and error views in the RIG API; Added tests for response\_from proxy behavior; Added tests for the Inbound Gateway's API proxy and proxy configuration validation; Kafka integration tests now support SSL and Avro serialization.

Added package.json and package-lock.json files for the channels-example frontend and service, establishing the Node.js dependencies (React, Hapi, KafkaJS) for the new examples. Also added mix.exs and mix.lock files for the NATS integration tests, specifying the Erlang dependencies (Gnat, Jason, Telemetry). Additionally, introduced a Maven pom.xml for the Kinesis client, defining Java dependencies (Amazon Kinesis Client, JUnit). These files define the build and runtime requirements for these specific components.

(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 → 63 (+10.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 97 (-1.6)
• Architecture 98 → 92 (-5.2)
• Maturity 73 → 71 (-2.1)
• Readiness 39 → 54 (+15.1)
• Security 44 → 61 (+16.6)

• Change coupling: event_controller.ex ↔ subscription_controller.ex (lib/rig_inbound_gateway_web/v1/event_controller.ex)
• Change coupling: health.ex ↔ router.ex (lib/rig_api/health.ex)
• Change coupling: kafka_to_filter.ex ↔ kinesis_to_filter.ex (lib/rig/event_stream/kafka_to_filter.ex)
• Change coupling: router.ex ↔ event_controller.ex (lib/rig_inbound_gateway_web/router.ex)
• Change coupling: sse.ex ↔ subscription_controller.ex (lib/rig_inbound_gateway_web/v1/sse.ex)
• Change coupling: sse.ex ↔ websocket.ex (lib/rig_inbound_gateway_web/v1/sse.ex)
• Context and decision are both present but the body is largely boilerplate boilerplate with a one-line 'In a nutshell' summary plus a bulleted list of ADR rules (immutable decisions, numbered without reuse, new ADR replaces old) that gives no real context or consequences (guides/architecture/decisions/0001-record-architecture-decisions.md)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (lib/rig_api/v2/session_blacklist.ex)
• Duplicated block (14 lines × 2) (lib/rig_inbound_gateway_web/v1/sse.ex)
• Duplicated block (25 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (29 lines × 2) (lib/rig_api/v2/messages.ex)
• Duplicated block (30 lines × 2) (lib/rig_api/v2/responses.ex)
• Duplicated block (7 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (8 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (8 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (9 lines × 2) (lib/rig_api/v2/session_blacklist.ex)
• Duplicated block (9 lines × 2) (lib/rig_inbound_gateway/api_proxy/handler/kafka.ex)
• High CVE: [GHSA redacted] (mix.lock)
• …and 44 more

• Documentation: contradicts the code (docs/rig-ops-guide.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (11 lines × 2) (lib/rig_inbound_gateway/api_proxy/handler/kafka.ex)
• Duplicated block (12 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (14 lines × 2) (lib/rig_api/v2/session_blacklist.ex)
• Duplicated block (15 lines × 2) (lib/rig_api/v2/session_blacklist.ex)
• Duplicated block (15 lines × 2) (lib/rig_inbound_gateway/api_proxy/handler/kafka.ex)
• Duplicated block (153 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (17 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (17 lines × 2) (lib/rig_inbound_gateway/api_proxy/handler/kafka.ex)
• Duplicated block (19 lines × 2) (lib/rig_inbound_gateway_web/v1/sse.ex)
• Duplicated block (27 lines × 2) (lib/rig_api/v2/session_blacklist.ex)
• Duplicated block (29 lines × 2) (lib/rig_api/v2/messages.ex)
• Duplicated block (33 lines × 2) (lib/rig/authorization_check/submission.ex)
• Duplicated block (39 lines × 2) (lib/rig_api/v2/responses.ex)
• Duplicated block (5 lines × 5) (lib/rig_api/v2/session_blacklist.ex)
• Duplicated block (7 lines × 2) (lib/rig_api/v2/session_blacklist.ex)
• Duplicated block (8 lines × 2) (lib/rig_api/v2/apis.ex)
• Duplicated block (9 lines × 2) (lib/rig_api/v2/apis.ex)
• …and 123 more

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

Accenture/reactive-interaction-gateway 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.