sequinstream/sequin

Sequin is a data streaming platform that captures PostgreSQL change data and routes it to a wide variety of sinks, including Kafka, AWS services, and various databases. The system provides a comprehensive web console for configuring sinks, managing backfills, and monitoring health, supported by a Go-based CLI for local development and configuration management. It features a modular runtime architecture that handles message transformation, routing, and delivery to destinations like Redis, RabbitMQ, and HTTP endpoints.

95 changes.

The project underwent a major rebranding from SequinStream to Sequin, accompanied by a complete frontend migration to a Svelte-based component library and Tailwind CSS design system. This period established the core multi-tenant account structure, implemented comprehensive API controllers and CLI tooling, and introduced extensive health monitoring and telemetry integrations.

38 changes.

This period focused on significantly expanding the platform's capabilities by adding support for numerous new data sinks, including Azure Event Hubs, Elasticsearch, Meilisearch, and various cloud messaging services. Concurrently, the team refactored the runtime architecture to support modular sink pipelines and introduced a new Functions editor with local storage persistence and strict validation. The work also included improving the developer experience through new Docker configurations for PostgreSQL replication and a redesigned static website.

Users can now create, list, and delete API tokens for their accounts. The system stores tokens securely using SHA-256 hashing and encryption, and provides functions to generate new tokens, find them by their raw value, and manage their lifecycle.

_lib/sequin/api\tokens · high confidence

The Kafka sink now supports authentication via AWS MSK IAM, enabling secure connections to Amazon Managed Streaming for Apache Kafka clusters using AWS credentials. A new \ConnectionCache\ GenServer manages and caches Kafka client connections, improving performance by reusing existing connections and automatically invalidating them when configuration changes. The \Kafka.Client\ module implements the publishing logic with exponential backoff retry for failed publishes, and the \Kafka\ module exposes a configurable interface for these operations.

lib/sequin/sinks/kafka · high confidence

Users can now configure AWS SNS as a sink. This includes a new Svelte icon, a configuration card displaying region, topic ARN, and routing details, and a form supporting both static and dynamic routing, including an option to use a LocalStack emulator for local development.

assets/svelte/sinks/sns · high confidence

A new Alert UI component has been added to the Svelte component library, consisting of an Alert container, an AlertTitle, and an AlertDescription. The Alert component supports multiple visual variants (default, destructive, warning, and info) to convey different message severities, allowing developers to display contextual notifications with appropriate styling.

assets/svelte/components/ui/alert · high confidence

Users can now send telemetry and events to Azure Event Hubs. The new sink supports publishing messages to a specified event hub and includes connection testing to validate namespace, shared access key name, and shared access key. The implementation uses SAS token-based authentication and sends JSON-encoded payloads directly without base64-encoding the message body.

lib/sequin/sinks/azure · medium confidence

Added a new example in the \examples/bash\_cpu\_metrics\ directory that demonstrates how to monitor CPU metrics using Bash scripts. The example includes \monitor.sh\ to collect and send CPU load and utilization data to a stream, and \load\_consumer.sh\ to consume and process those messages, providing a practical use case for testing and development.

_examples/bash\_cpu\metrics · high confidence

A new page for the Sequin CLI has been added, providing users with multiple installation methods (Homebrew, shell script, and source build) and instructions for configuring the CLI with a server host and API key. The page includes copy-to-clipboard functionality for commands and a dropdown to select from available API tokens.

assets/svelte/cli · high confidence

Introduces a new Elixir module, \Sequin.Datadog\, that provides a client for the Datadog Incident Management API. This addition enables the application to create, retrieve, update, delete, list, and search for incidents, along with a helper to paginate through all incidents. The change also includes the \Sequin.Datadog.Incident\ struct to represent incident data, facilitating structured interaction with the Datadog service.

lib/sequin/datadog · high confidence

Added a new Docker Compose configuration in the \docker/replica-physical-cdc-dev\ directory to facilitate local development of PostgreSQL physical streaming replication. The setup includes a primary database instance on port 7432 and a hot standby replica on port 7452. The configuration uses PostgreSQL 17.4 and includes initialization scripts to set up replication slots and user permissions, enabling users to easily spin up a primary-replica environment for testing data replication.

docker/replica-physical-cdc-dev · high confidence

The Ecto layer now includes custom type definitions for handling errors and maps with integer keys. A new \Sequin.Ecto.Error\ type allows Ecto schemas to store and retrieve error structures, while \Sequin.Ecto.IntegerKeyMap\ enables seamless conversion between maps with string keys and maps with integer keys, improving data handling for these specific data types.

lib/sequin/ecto · medium confidence

The Elasticsearch sink client is now implemented in \lib/sequin/sinks/elasticsearch/client.ex\. This adds the core logic for interacting with the Elasticsearch API, including importing documents in NDJSON format, testing connections, and handling authentication headers (API key, Basic, Bearer). The client supports retry mechanisms and body compression.

lib/sequin/sinks/elasticsearch, lib/sequin/sinks/s2 · high confidence

Users can now configure and manage Elasticsearch sinks, including setting the endpoint URL, authentication type (None, API Key, Basic Auth, or Bearer Token), and routing options. The new UI components allow users to specify an index name or use dynamic routing via a transform function, with appropriate form fields and validation errors displayed.

assets/svelte/sinks/elasticsearch · high confidence

The examples/elixir\_broadway directory now contains a complete example project demonstrating how to build a Broadway data processing pipeline using the OffBroadwaySequin library. This includes the main application module (ExampleBroadway) which configures the Broadway producer and processors, an OTP application supervisor, and associated test files. The example serves as a quick-start template for developers looking to integrate Sequin streams with Broadway.

_examples/elixir\broadway · high confidence

A new GCP Pub/Sub sink has been introduced, enabling users to send data to Google Cloud Pub/Sub topics and subscriptions. The change includes a dedicated credentials module (Sequin.Sinks.Gcp.Credentials) that supports service accounts, OAuth clients, and API keys, with sensitive fields like private keys and secrets encrypted or excluded from inspection logs. The Pub/Sub client implementation provides methods for publishing and pulling messages, acknowledging messages, and testing connections, including support for the GCP Pub/Sub emulator via a :use\_emulator option.

lib/sequin/sinks/gcp · high confidence

Users can now configure AWS Kinesis as a data sink, including a new icon, a configuration form, and a display card. The form supports both static Stream ARN and dynamic routing to a function. The configuration card displays region, stream ARN, and routing details, and provides a link to the AWS Console. The form also integrates with the existing AWS authentication form, allowing credentials to be loaded from task role, environment, or profile.

assets/svelte/sinks/kinesis · high confidence

Users can now send data to a Meilisearch index. The new \Sequin.Sinks.Meilisearch.Client\ module supports importing, deleting, and updating documents via the Meilisearch API, including handling asynchronous task status checks with exponential backoff retries.

lib/sequin/sinks/meilisearch · high confidence

Users can now configure a Meilisearch sink, including setting the endpoint URL, primary key, and API key. The new Meilisearch sink card displays configuration details and index name, while the form allows users to define routing functions for partial updates using Meilisearch's function capability.

assets/svelte/sinks/meilisearch · high confidence

Users can now configure and view NATS sink connections, including host, port, TLS, username, password, JWT, and NKey Seed. The new NatsSinkCard component displays connection details and routing information, while the NatsSinkForm provides a UI for setting up NATS connections. Additionally, the NatsIcon component is added for visual identification.

assets/svelte/sinks/nats, assets/svelte/sinks/sqs · medium confidence

Added the NATS sink implementation, including the client module for sending messages and testing connections, along with a connection cache to manage and reuse NATS connections. The client handles publishing messages with headers and transforming messages, while the connection cache stores and invalidates connections based on sink configuration changes.

lib/sequin/sinks/nats · high confidence

Added a new Docker Compose configuration and supporting scripts to set up a PostgreSQL logical replication environment for development. This includes a primary database instance on port 7432 and a replica on port 7452, configured with a publication and subscription to enable data replication between them.

docker/replica-cdc-dev · high confidence

Added a new Postgres virtual backend and benchmarking infrastructure to enable performance testing and development without a live Postgres connection. This includes a \VirtualBackend\ that adapts virtual \Source\ implementations to the replication protocol, a \BenchmarkSource\ that generates synthetic WAL messages with configurable row/transaction sizes and collision rates, and a \MessageHandler\ that records throughput and checksums for validation. Supporting files include a \Backend\ behaviour, a \Source\ behaviour, and utilities like \ArrayLexer\ for parsing Postgres array literals and \ValueCaster\ for type casting, including support for \pgvector\ and improved \interval\ handling.

lib/sequin/postgres · high confidence

Users can now configure a RabbitMQ sink to route and publish transformed messages to RabbitMQ. The implementation includes a new client module that handles message publishing and connection testing, alongside a connection cache to manage and reuse RabbitMQ channels for improved performance. The sink supports routing information including exchange, headers, routing key, and message ID, allowing for flexible message routing within RabbitMQ.

lib/sequin/sinks/rabbitmq · high confidence

Users can now configure and view settings for a Redis String sink. The change introduces a form (RedisStringSinkForm) allowing configuration of host, port, username, password, database, batch size, and TLS, along with an expiration time setting. A corresponding display component (RedisStringSinkCard) shows the current configuration, including URL, expiration, key pattern, and routing function code if dynamic routing is active.

(repo-wide) · medium confidence

A new Sonner-based toast notification component has been introduced to the UI library. The Svelte wrapper integrates the underlying 'svelte-sonner' library and automatically applies the current theme (light/dark mode) via a mode watcher, ensuring toast notifications match the application's visual style.

assets/svelte/components/ui/sonner · high confidence

A new Svelte Button component has been introduced in the UI library, wrapping bits-ui with Tailwind-variants for styling. The component supports multiple visual variants (default, destructive, outline, secondary, ghost, link, magic, and menu) and sizes (default, sm, lg, icon, menu). A key behavioral addition is native loading state management: when the 'loading' prop is true, the button displays a spinner and a 'Loading...' slot, with a configurable minimum display time (default 500ms) to prevent flickering during rapid state changes.

assets/svelte/components/ui/button · high confidence

A new Svelte-based Skeleton component has been introduced to provide a visual placeholder for loading states. The component renders a pulsing, rounded rectangle using Tailwind utility classes (bg-muted, animate-pulse, rounded-md) and accepts a custom class prop, allowing developers to easily integrate a standard loading skeleton into their interfaces.

assets/svelte/components/ui/skeleton · high confidence

A new Svelte-based Table component has been introduced, providing a complete set of sub-components for building data tables. The implementation includes a root Table component along with TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, and TableRow. These components are exported from the table module, enabling users to construct structured, styled tables within their Svelte applications.

(repo-wide) · medium confidence

New Svelte components have been added to the UI library, providing a complete set of building blocks for modal drawers and dropdown menus. The drawer set includes components for the root, content, header, footer, title, description, and overlay, all wrapping the vaul-svelte library. The dropdown menu set provides items, checkboxes, radio groups, labels, separators, and sub-menus, wrapping the bits-ui library. These components are exported from their respective index files for easy integration into the application.

assets/svelte/components/ui/drawer, assets/svelte/components/ui/dropdown-menu · high confidence

Introduced new Svelte components for building tabbed interfaces, including Tabs, TabsContent, TabsList, and TabsTrigger. These components are built on top of the bits-ui library and provide a consistent, accessible way to manage tabbed navigation and content switching within the application's UI library.

assets/svelte/components/ui/tabs · high confidence

The repository now includes a complete example project in \examples/sequin-cdc-to-temporal\ that demonstrates how to build a Temporal workflow triggered by a CDC webhook. The example provides an Express server (\src/server.ts\) that receives Sequin webhook events, uses Temporal's signal-with-start pattern to initiate a long-lived workflow (\src/workflows.ts\) that performs user deletion cleanup activities (\src/activities.ts\) via a dedicated worker (\src/worker.ts\). The directory also includes all necessary configuration files (\.eslintrc.js\, \.prettierrc\, \tsconfig.json\, etc.) and a basic test (\src/mocha/example.test.ts\) to support the tutorial.

examples/sequin-cdc-to-temporal · high confidence

Introduced a new Typesense sink client that enables indexing single documents, batch importing JSONL documents, and deleting documents via the Typesense API. The client supports configurable timeouts, request options, and detailed tracing of success and failure states for each operation.

lib/sequin/sinks/typesense · high confidence

Introduced a new \ExpandableCard\ component that supports toggling between a summary and full content, along with supporting card parts (header, title, content, description, footer) to enable collapsible UI patterns.

assets/svelte/components/ui/card · high confidence

A new Textarea component has been added to the UI library, providing a styled, accessible text input with support for standard HTML textarea attributes, event bindings (blur, change, click, focus, keyboard, mouse, paste, and input events), and CSS class integration via the cn utility.

assets/svelte/components/ui/textarea · high confidence

A new Svelte Badge component has been introduced, providing a reusable UI element that renders as a link or span with Tailwind-variants styling. It supports multiple status variants including default, secondary, destructive, outline, active, disabled, healthy, warning, error, and initializing, allowing users to quickly apply consistent styling for different states.

assets/svelte/components/ui/badge · high confidence

Added routing consumers for Azure Event Hubs, Elasticsearch, GCP Pub/Sub, HTTP push, Kafka, AWS Kinesis, Meilisearch, NATS, RabbitMQ, Redis (Stream and String), S2, AWS SNS, AWS SQS, and Typesense. Each new consumer module defines how data is routed to the respective sink, including validation rules, default routing logic, and consumer-specific configuration fields.

lib/sequin/runtime/routing/consumers · high confidence

A new deployment configuration named \terraform-ecs-ec2-sqs\ has been added to the \deployment\ directory. This specialized setup extends the standard EC2-based deployment with AWS SQS queues and related IAM policies to support the HTTP Push Consumer feature. The configuration includes infrastructure for SQS queues, dead-letter queues, and the necessary IAM roles and policies to allow the application to send and receive messages via SQS. This deployment is marked as special and not for widespread use, intended only for specific use cases where SQS integration is required.

deployment · high confidence

The application now includes a complete set of Phoenix LiveViews for user authentication and account management. This includes pages for logging in, registering, confirming email addresses, resetting passwords, and managing user settings (such as changing passwords and email addresses). Additionally, a new AcceptInviteLive view handles the flow for users accepting team invitations, and a CLI page displays API tokens. The home page now redirects users to the appropriate dashboard or setup flow based on their account status.

_lib/sequin\web/live · high confidence

The CLI now includes the full Chisel client implementation, enabling users to establish secure tunnels to a Chisel server. This change adds the client-side logic for connecting, authenticating, and managing SSH-based tunnels, including support for TCP, UDP, and SOCKS5 proxying. Users can now configure remotes, set up reverse tunnels, and manage connections with features like automatic retry with exponential backoff, TLS/mTLS support, and custom headers.

cli/chisel · high confidence

The project now includes the Heroicons v2.0.16 icon library, providing a comprehensive set of optimized SVG icons in the 'solid' style. This update adds licensing and upgrade documentation for the library, along with the full set of 20x20px solid SVG icons, enabling the use of these visual assets within the application's interface.

assets/vendor · high confidence

A new GenServer-based reporter has been added to capture and batch-process telemetry events from the Sequin consumer. It listens for 'sequin.posthog.event' telemetry, specifically merging 'consumer\_receive' and 'consumer\_ack' events by consumer ID to report aggregated metrics like message count, byte processing totals, and consumer name to PostHog.

lib/sequin/telemetry · high confidence

Introduced new modules for decoding PostgreSQL logical replication messages (BEGIN, COMMIT, INSERT, UPDATE, DELETE, and TRUNCATE) and mapping PostgreSQL type IDs to descriptive names, enabling the system to parse and interpret database change events.

_lib/sequin/runtime/postgres\adapter · high confidence

A new Svelte component, RedisIcon.svelte, was added to provide a visual identifier for the Redis String sink. This change supports the broader update to the sink type icon grid, ensuring the interface has the necessary visual elements to display the new sink type.

_assets/svelte/sinks/redis\shared · high confidence

New Svelte components have been introduced to support dialog and label UI patterns. The dialog module now includes a complete set of sub-components (Content, Description, Footer, Header, Overlay, Portal, Title) built on top of bits-ui, enabling structured dialog layouts with standard styling and transitions. Additionally, a new Label component has been added to provide accessible, styled label elements for form inputs.

assets/svelte/components/ui/dialog · high confidence

Introduced \Sequin.Functions.MiniElixir\ to handle the execution of user-defined transform functions (both compiled and interpreted) with a 1-second timeout and feature-flag gating. Added \Sequin.Functions.TestMessages\ to manage an in-memory ETS store of test messages, allowing users to view before/after states when writing functions in the console, with support for adding, retrieving, and deleting these test messages.

lib/sequin/functions · medium confidence

New Svelte components for Checkbox and Switch controls have been introduced, each wrapping their respective primitives from the 'bits-ui' library. The Checkbox component renders a check or minus icon based on its state, while the Switch component provides a toggleable slider with distinct checked and unchecked visual states.

assets/svelte/components/ui/checkbox, assets/svelte/components/ui/switch · high confidence

A new one-off task, MigratePostgresDbs, has been added to the Sequin application. This task provides functionality to migrate sequences and sink consumers between PostgreSQL databases and replication slots, allowing users to move data from a source database to a target database while preserving schema and generating new identifiers. The task includes methods to migrate sequences and sink consumers, handling the creation of new records in the target database and reporting success/failure counts.

lib/sequin/tasks · high confidence

The examples/user-specific-webhooks directory now includes a complete working example for building user-specific webhook subscriptions. This includes a Node.js Express server (server.js) that provides /subscribe and /backfill endpoints, a notification generator script (generate-notifications.js) for testing, and supporting files (.gitignore, README.md) that document setup, prerequisites, and testing steps.

examples/user-specific-webhooks · high confidence

The system now supports writing consumer message logs to a local file (consumer\_messages.log) for self-hosted deployments, providing a fallback when the Datadog integration is not configured. This change introduces new modules (Sequin.Logs.Log, Sequin.Logs, Sequin.Logs.RotateLogsWorker) that handle writing log entries to disk and rotating the log file. If the file system is read-only, the system gracefully handles write failures without raising errors. Users can now view consumer message logs via the file-based log or through Datadog if enabled.

lib/sequin/logs · high confidence

The Dockerized environment now automatically initializes a PostgreSQL database named 'sequin\_playground' containing a 'products' table with sample data. The setup includes a trigger to automatically update timestamps on row modifications and configures logical replication by creating a publication and a replication slot, facilitating immediate use of the quickstart guide.

docker/postgres-init · high confidence

The sink consumer interface is now managed through a new \Form\ LiveView that handles both creating and editing consumers via a shared \ConsumerForm\ component, while the \Index\ view introduces paginated listing with async-loaded metrics and health status. This refactoring unifies the creation and editing workflows, allowing users to manage sink consumers through a consistent UI that displays real-time throughput, health checks, and backfill status across all supported sink types.

_lib/sequin\_web/live/sink\consumers · high confidence

The application now supports encrypting binary, map, and embedded schema fields using the Cloak library. New modules (Sequin.Encrypted.Binary, Sequin.Encrypted.Map, and Sequin.Encrypted.Field) provide encrypted storage capabilities, with the field module specifically handling JSON serialization and Base64 encoding for nested data.

lib/sequin/encrypted · high confidence

Added a new Sequin.Aws module that provides a callback-based interface for AWS operations, allowing for easy mocking and testing. This includes a default implementation (Sequin.Aws.Client) that resolves AWS credentials from ECS task roles, environment variables, or explicit access keys. Additionally, new modules were added for AWS services: Sequin.Aws.Kinesis for Kinesis stream operations, Sequin.Aws.SNS for SNS topic management, and Sequin.Aws.SQS for SQS queue management. These modules handle credential resolution, message publishing/receiving, and error handling for their respective AWS services.

lib/sequin/aws · high confidence

Added a new \cli/api\ package that provides a Go client for interacting with the Sequin API. This includes a \Client\ struct, an \API\ interface, and comprehensive error handling with \ValidationError\ and \APIError\ types that parse and display API responses. The \stream.go\ file contains the initial scaffolding for stream operations (fetching, adding, removing), though the actual HTTP request and response logic is currently commented out, indicating this is a foundational layer for future CLI features.

cli/api · high confidence

The CLI directory now includes a Makefile and shell scripts (build\_and\_install.sh, build\_releases.sh, release.sh, installer.sh) that enable building the sequin binary for development and production, installing it to the user's local bin directory, and automating multi-platform release packaging and Homebrew formula updates. This provides the infrastructure for local development builds and automated release workflows.

cli · high confidence

The Functions feature is now accessible via a new index page and an edit interface, allowing users to manage and edit function code directly in the browser. The edit page provides a code editor with auto-complete for Elixir standard library modules and functions, as well as pre-filled templates for various routing and enrichment scenarios. The index page lists all functions with their associated consumers, enabling users to view, delete, and navigate to the editor for each function.

_lib/sequin\web/live/functions · high confidence

Added a new HTTP Endpoints feature allowing users to configure and manage endpoints for pushing records to external services. The update introduces a new Form component for creating and editing HTTP endpoints, including support for encrypted headers and local tunneling. An Index component displays a list of HTTP endpoints with health status and throughput metrics. A Show component provides detailed information about a specific endpoint, including base URL, health summary, and throughput. The Index and Show components also include empty states and call-to-action buttons to guide users in creating their first HTTP endpoint.

_assets/svelte/http\endpoints · high confidence

Added new Ecto schemas for managing Postgres replication slots and WAL (Write-Ahead Log) pipelines. The \PostgresReplicationSlot\ model tracks slot status, annotations, and partitioning, while the \WalPipeline\ model defines the structure for processing WAL events, including source table configurations and column filters. These models support the underlying infrastructure for database replication and data ingestion.

lib/sequin/replication · high confidence

The CLI now supports managing configuration via YAML files. Users can use \sequin config plan\ to preview changes, \sequin config apply\ to apply them (with an optional \--auto-approve\ flag to skip interactive confirmation), and \sequin config export\ to save the current state to a YAML file. The \config interpolate\ command allows users to resolve environment variables in their YAML files. Additionally, context management commands (\context add\, \context select\, \context edit\) and a \tunnel\ command for establishing secure tunnels have been added.

cli/cli · high confidence

Adds the core domain models for accounts, users, and their many-to-many relationship, enabling users to belong to multiple accounts. The change introduces an impersonation feature that allows authorized users to temporarily assume the identity of another user via a time-limited, Redis-backed secret link. Additionally, it adds email notification templates for account invitations and standard authentication flows (confirmation, password reset, email update).

lib/sequin/accounts · high confidence

Added a new benchmarking library (Sequin.Bench) for performance testing, along with a system health check module (Sequin.CheckSystemHealth) that validates connectivity to Postgres and Redis, with a corresponding background worker (CheckSystemHealthWorker) to run these checks periodically. The application startup (Sequin.Application) was updated to initialize ETS tables and start the health check worker, while the debounced logger (Sequin.DebouncedLogger) was integrated into the application tree.

lib/sequin · high confidence

The CLI now supports managing configuration through new commands: \sequin config plan\ shows the planned changes, \sequin config apply\ executes them, and \sequin config export\ outputs the processed YAML. The \config.go\ implementation adds environment variable interpolation (with support for default values and file embedding), allowing users to reference environment variables in their YAML configurations. Tests verify the interpolation logic and the \Interpolate\ function's behavior with files and stdout.

cli/config · medium confidence

The system now supports applying custom Elixir functions to transform, filter, route, or enrich messages before they are sent to sinks. This new capability allows users to modify message data, apply conditional logic, or add metadata during the ingestion pipeline. The implementation introduces a \Message\ transform module that handles the execution of these functions, integrating with the existing sink consumer architecture to ensure that all configured transformations are applied consistently across different sink types.

lib/sequin/transforms · high confidence

The CLI now supports managing multiple contexts, each storing connection details like hostname, TLS settings, and API tokens in the user's home directory (\~/.sequin/contexts). Users can save, load, list, and remove contexts, and set a default context to streamline authentication and server URL resolution. Configuration is split into build-tagged files (config\_dev.go and config\_prod.go) to handle environment-specific defaults, such as the default port (4000 for dev, 7376 for prod).

cli/context · high confidence

The runtime layer is refactored to use a modular \SinkPipeline\ behavior, allowing distinct pipeline implementations for each destination type. New pipeline modules are added for Azure Event Hubs, Elasticsearch, GCP Pub/Sub, Kafka, and AWS Kinesis, each handling message routing, batching, and delivery logic specific to the target service. Additionally, a \BenchmarkPipeline\ is introduced for end-to-end testing, and lifecycle workers are added to manage the startup, update, and teardown of consumer and database resources. This structure replaces the previous monolithic handling, enabling independent scaling and configuration for each sink type.

lib/sequin/runtime · high confidence

Users can now create, edit, and manage HTTP endpoints through a dedicated interface. The new forms validate endpoint reachability and connectivity before saving, and the index and show pages display real-time health status and throughput metrics.

_lib/sequin\_web/live/http\endpoints · high confidence

Added new Svelte components (HealthAlerts, HealthIcon, HealthPill, HealthSummary) and a shared Types definition to display health status, errors, and warnings in a consistent, color-coded manner. Users will now see detailed health summaries, individual check statuses (healthy, error, warning, initializing, paused, notice), and actionable alerts with refresh and dismiss options.

assets/svelte/health · high confidence

The application now includes new layout and sidebar components that support account switching and account creation. The sidebar component tracks the earliest sink insertion time and displays a contact email alert if a sink has been created for more than 5 minutes. The layout system provides multiple layout variants (with/without sidebar or main content). Additionally, a new alert component system has been added, supporting default, destructive, and warning variants with title and description slots.

_lib/sequin\web/components · high confidence

Added a new \AcknowledgedMessages\ module that stores acknowledged messages in a Redis sorted set, enabling retrieval and counting of messages per consumer. The \AcknowledgedMessage\ struct was created to represent these messages, including fields for commit LSN, index, delivery count, and state. The implementation ensures that the \deliver\_count\ is at least 1 for delivered messages, and includes migration logic to handle legacy \seq\ fields. This change supports the 'messages' tab in the UI by providing a backend store for acknowledged messages.

_lib/sequin/consumers/acknowledged\messages · high confidence

Adds new utility functions to the Svelte frontend, including helpers for formatting relative timestamps, truncating text, generating deterministic color classes from names, and applying fly/scale transitions. Also includes a CSS import in the main App component and TypeScript declarations for MDX modules.

assets/svelte · high confidence

Added Svelte components for the Kafka sink configuration: a new icon, a card displaying consumer details (hosts, topic, TLS, compression), and a form supporting SASL authentication (Plain, SCRAM, AWS MSK IAM) and AWS credentials. The card also displays routing information when applicable.

assets/svelte/sinks/kafka · high confidence

The website has been rebuilt as a static site, introducing a new 404 error page, a responsive mobile navigation menu, and an async-loaded Google font (JetBrains Mono). The site now features a clean header with a GitHub link, a hero section highlighting Postgres change data capture, and a customer logo section. Additionally, the cloud button has been removed from the header.

website · high confidence

This change introduces three new plugs to the web layer: a fallback error handler for API routes, a token verification plug for API authentication, and a content-type validation plug. The ApiFallbackPlug standardizes error responses across the API, while the VerifyApiToken plug enforces Bearer token authentication, and the VerifyContentType plug ensures requests use application/json. These components work together to secure API endpoints and provide consistent error handling.

_lib/sequin\web/plugs · high confidence

The update introduces a suite of new API controllers in the \lib/sequin\_web/controllers\ directory, enabling programmatic management of various platform resources. These include \ApiKeyController\ for managing API tokens, \BackfillController\ for managing backfill jobs for sink consumers, \ConsumerJSON\ for consumer data, \HttpEndpointController\ for managing HTTP endpoints, \PostgresDatabaseController\ for database and replication slot management, \PostgresReplicationController\ for replication resources, \PullController\ for consuming messages from streams, \PushWebhookController\ for handling webhooks, \SinkConsumerController\ for managing sink consumers, and \YamlController\ for applying, planning, and exporting YAML configurations. Additionally, \HealthCheckController\ provides system health status, \InfoController\ exposes version and node information, \LocalTunnelController\ manages local tunnel entities, and \UserSessionController\ handles GitHub OAuth login, logout, and user impersonation. The \MessageController\ is present but currently contains only commented-out code, indicating a placeholder or work-in-progress state.

_lib/sequin\web/controllers · high confidence

Added a complete set of Svelte components for building alert dialogs, including Action, Cancel, Content, Description, Footer, Header, Overlay, Portal, and Title, all wrapping the 'bits-ui' primitives to provide a ready-to-use dialog experience.

assets/svelte/components/ui/alert-dialog · high confidence

A complete rewrite of the Databases interface, introducing new Phoenix LiveViews (Form, Index, Show) that render Svelte components for database management. This change introduces the ability to create, edit, and view databases with features like connection testing, replication slot management, and health status updates. The index view lists all databases with their health and consumer counts, while the show view allows users to restart, enable/disable, and manage replication slots. The form handles database creation and updates, including API token management and local tunnel prompts.

_lib/sequin\web/live/databases · high confidence

Users can now run Sequin locally or in CI pipelines using a new set of Docker Compose configurations. The \docker/docker-compose.yaml\ file provides a full local stack including PostgreSQL, Redis, Prometheus, and Grafana with pre-configured dashboards. A separate \docker/docker-compose.ci.yaml\ offers a lightweight configuration for CI environments, excluding heavy monitoring services. Additionally, a \Dockerfile.dev-bundle\ is provided for creating a stateless, Docker-in-Docker environment for testing, and a \playground.yml\ template is included to quickly configure a local database connection.

docker · high confidence

Added four new Mix tasks in lib/mix/tasks to support development and operations workflows. The \bench\ task runs an end-to-end pipeline benchmark with configurable parameters (duration, row/transaction sizes, profiling). The \buildpush\ task automates Docker image building and pushing to ECR and Docker Hub, including branch and signoff verification. The \merge\ task automates GitHub PR merging after verifying signoff status. The \signoff.stack\ task iterates through a Graphite PR stack, signing off on each PR from bottom to top. These changes introduce new capabilities for testing, deployment, and code review automation.

lib/mix · high confidence

The console UI received a suite of new Svelte components to support updated data flows and user interactions. Users can now configure AWS authentication using task roles or explicit keys via the new AwsAuthenticationForm. Backfill creation and management are handled by the new BackfillForm, which supports multi-table selection, sort column auto-selection, and start position configuration. The interface also gains several utility components: a Beta tag for feature status, CodeWithCopy and CollapsibleCode for displaying code snippets, a Datetime picker for date/time inputs, and a DeleteFunctionDialog for safe deletion. Additionally, the Sidenav is rebuilt to include new navigation items like Sinks, Change Retention, and HTTP Endpoints, while helper components like LinkPatchNavigate and MessageExamples are introduced to improve navigation and documentation display.

assets/svelte/components · high confidence

Added four new Svelte components in the UI library: CopyToClipboard for copying text with fallback support, form-error-message and form-item for structured form validation display, and form-toggle-visibility-button for password fields. These components provide reusable, styled UI elements for common form interactions.

assets/svelte/components/ui · high confidence

Added new Svelte components for account and user settings. Users can now manage their account by renaming or deleting it, managing API tokens, and viewing pending invites. Users can also update their email address and change their password, with appropriate restrictions for GitHub-authenticated users.

assets/svelte/settings · high confidence

A new AccountSettingsLive LiveView has been added to the settings area, introducing a dedicated interface for managing account details. Users can now rename accounts, update contact emails, and manage API tokens (create and delete). The page also supports team management, allowing users to invite new members via email, revoke existing invitations, and remove users from an account.

_lib/sequin\web/live/settings · high confidence

The application now uses new layout templates for the main application shell and the root HTML document. The app layout introduces a flexible container with a conditional sidebar navigation and a main content area, while the root layout integrates the page title, static assets, and external scripts (including Wistia embeds). Additionally, the root layout includes a banner to display an active user impersonation state, allowing users to easily end the impersonation session.

_lib/sequin\web/components/layouts · high confidence

The consumers module now includes new Ecto schemas and context logic to support backfills, consumer events, and various sink types. Specifically, the diff introduces \Backfill\ and \ConsumerEvent\/\ConsumerEventData\ models to track backfill states and consumer message history. It also adds configuration schemas for multiple new sink types, including Azure Event Hub, Elasticsearch, GCP Pub/Sub, Kafka, Kinesis, Meilisearch, and HTTP endpoints, each with their own changesets and validation rules. Additionally, the \Function\ model is expanded to support polymorphic embeddings for routing, filter, and enrichment functions, while \HttpEndpoint\ and \BenchmarkSink\ schemas are introduced to support HTTP push destinations and internal benchmarking.

lib/sequin/consumers · high confidence

The repository now includes a top-level Makefile to standardize development workflows, including targets for running the app locally, running signoff checks, and managing end-to-end tests. A new \.iex.exs\ file configures the IEx environment with auto-reload and imports helper modules and aliases for common domain types. Additionally, new markdown files (\AGENTS.md\, \ADD-SINK.md\, \ADD-SINK-ROUTING.md\) provide structured guides for AI agents and developers on how to add new sinks and implement routing, while \CHANGELOG.md\ and \gen-readme.md\ automate and document the changelog and README generation processes.

(repo-wide) · high confidence

Sequin introduces a new health check system that monitors the status of Postgres replication slots, HTTP endpoints, and sink consumers. The system records health events (e.g., connectivity, message ingestion, delivery status) and aggregates them into a consolidated health state (healthy, warning, error, etc.) for each entity. This enables real-time visibility into the health of data pipelines and endpoints, with automated health snapshots and alerts for failures or warnings.

lib/sequin/health · high confidence

The system now exposes live metrics and entity health status to power the Console's monitoring views. A new \Sequin.Metrics\ context and \Sequin.Metrics.Store\ backend (backed by Redis) track throughput, latency, and counters for consumers, databases, and replication slots. Additionally, \Sequin.Metrics.EntityHealthMetrics\ reports the current health status of sinks, databases, and replication slots as Prometheus gauges, enabling real-time visibility into component health in the UI.

lib/sequin/metrics · high confidence

Added new shell scripts to streamline developer workflows: \checkout\_pr.sh\ and \signoff\_pr.sh\ allow checking out and signing off on pull requests, including support for cross-repository forks; \delete\_branch.sh\ safely deletes local branches with confirmation prompts; \merge.sh\ automates merging pull requests with signoff verification and branch cleanup; \release.sh\ handles local release builds and uploads; \signoff.sh\ and \signoff\_stack.sh\ manage CI signoff checks and Graphite stack signoffs; \start\_commands.sh\ manages application startup, configuration loading, and agent address setup; \tag-release.sh\ manages version tagging and release workflow triggers; \test\_loop.exs\ runs tests continuously to detect flakiness; \load\_postgres.exs\ provides a load testing script for PostgreSQL; \cli\_tmux\_forwarder.sh\ forwards keystrokes across tmux panes; \redis-console-consumer.sh\ consumes from Redis streams; and \release-notes-template.txt\ provides a template for generating release notes.

scripts · high confidence

The consumers directory now includes a suite of new Svelte components that power the updated sink management interface. This includes \ShowSink\ and \ShowSinkHeader\ for displaying sink details, status, and actions; \ShowBackfills\ for managing and monitoring backfill jobs; \ShowMessages\ for viewing and acknowledging messages; and \DynamicRoutingForm\ and \FunctionPicker\ for configuring dynamic routing and transform functions. Additionally, \ColumnList\ and \GroupColumnsForm\ provide UI for selecting grouping columns, while \HttpPullVisual\ and \HttpPushVisual\ offer animated visualizations of data flow. These components collectively enable users to create, monitor, and troubleshoot sinks directly from the console.

assets/svelte/consumers · high confidence

The application now remembers the state of the side navigation and the current page context. A new Svelte store in assets/svelte/stores/Sidenav.js persists the collapsed state of the side navigation bar to localStorage, ensuring the UI remembers the user's last interaction. Additionally, a new pageStore in assets/svelte/stores/pageStore.ts is introduced to manage page state, supporting the persistence of pagination state when navigating between pages.

assets/svelte/stores · medium confidence

The RabbitMQ sink assets have been reorganized into a dedicated directory, introducing new Svelte components for managing and displaying RabbitMQ sink details. The new \RabbitMqSinkForm\ provides a user interface for configuring connection parameters (host, port, virtual host, credentials, TLS) and routing settings (exchange, headers, routing key), including support for dynamic routing functions. The \RabbitMqSinkCard\ displays the current configuration, while the \RabbitMqIcon\ provides a visual identifier for the sink type.

assets/svelte/sinks/rabbitmq · high confidence

The database management interface has been completely rebuilt with new Svelte components. The database form now supports local storage persistence, automatic SSL configuration for Supabase, and connection string autofill. The database index and show pages now display health status, sink consumer counts, and pipeline counts. A new 'Change Retention' (formerly WAL Projections/Pipelines) view allows users to manage data retention pipelines. The messages page now displays all replicated messages with detailed trace information. The database header includes restart, pause/resume, and delete actions.

assets/svelte/databases · high confidence

The default Phoenix application templates and layout files have been removed. This includes the \SequinStreamWeb.Layouts\ module, the \app.html.heex\ and \root.html.heex\ layout templates, the \PageController\ and its \home.html.heex\ template, and the \router.ex\ configuration that wired the root path to the page controller. As a result, the application no longer serves the default Phoenix welcome page or uses the standard layout structure out of the box.

_lib/sequin\_stream\web · high confidence

The system now supports capturing and encoding PostgreSQL range types (Postgrex.Range) and lexemes during table state capture. This allows range data to be serialized into JSON format, enabling these specific database types to be included in the captured state.

lib/sequin/postgrex · medium confidence

A new validator module (Sequin.Functions.MiniElixir.Validator) was added to enforce strict rules for MiniElixir functions. It ensures that functions are defined at the top level with specific names (transform, route, or filter) and accept a fixed set of arguments (action, record, changes, metadata). The validator also restricts the allowed operations, built-in functions, and kernel sigils to a safe subset, preventing the use of arbitrary code in function definitions.

lib/sequin/functions/minielixir · medium confidence

A new MDX file, function-transform-snippet.mdx, has been added to the assets/svelte/mdx directory. This file acts as a symbolic link to the corresponding snippet in the docs/snippets directory, making the function transform content available within the Svelte asset structure.

assets/svelte/mdx · high confidence

A new .keep file has been added to the rel directory. This ensures the directory is tracked by version control, which is often done to preserve directory structure in repositories that ignore empty directories.

rel · low confidence

The separate UI for creating and editing sinks has been merged into a unified \ConsumerForm\ component. This change simplifies the interface by using a single form for both new and existing sinks, handling validation, submission, and error states within one LiveComponent, which streamlines the user experience when managing sink configurations.

_lib/sequin\web/live/components · high confidence

The database schema was updated to support multi-tenant accounts, API access, and flexible message routing. A new \accounts\_users\ join table was introduced to allow users to belong to multiple accounts, while the previous single-tenant \users.account\_id\ was relaxed to allow nulls. API tokens and user tokens gained \annotations\ and \extra\ fields for metadata. The \http\_push\_consumers\ and \http\_pull\_consumers\ tables were merged into a polymorphic \sink\_consumers\ table, enabling different sink types (like HTTP push or stream-based) to share a common schema. Additionally, WAL (Write-Ahead Log) pipelines and events were added to track database changes, and various consumer tables received new columns for tracing (\trace\_id\), grouping (\group\_id\), and configuration (\batch\_size\, \sort\_column\_attnum\).

priv/repo/migrations · high confidence

The application now integrates PostHog for analytics and session recording, Koala for telemetry, and Intercom for customer messaging. User identification events (phx:ph-identify) now send user and account data to all three services. A new toast notification system using svelte-sonner has been added to display UI messages. Additionally, the LiveView socket configuration now dynamically reads the long-poll fallback duration from a data attribute, and Svelte components are registered for rendering.

assets/js · medium confidence

Users can now create, view, and manage 'Change Capture Pipelines' (formerly WAL Projections) to track changes in specific database tables. This new interface allows users to select a source table, apply column-level filters, and monitor pipeline health and metrics. The system enforces that the source table must be part of the database's publication and prevents using event tables as sources, providing clear error messages if these constraints are violated.

_lib/sequin\_web/live/wal\pipelines · high confidence

Added a ConnectionCache to cache and reuse database connections, reducing startup penalties for repeated operations. Introduced DatabaseUpdateWorker and EnqueueDatabaseUpdateWorker to periodically refresh database table metadata and update the system's internal state. These changes improve performance and ensure the system maintains an up-to-date view of database schemas.

lib/sequin/databases · high confidence

The CLI now includes a new models package containing Go structs for representing stream data, including fields for ID, index, name, statistics, and timestamps. This change organizes the CLI's data structures into a dedicated package, separating model definitions from other CLI logic.

cli/models · medium confidence

The application's configuration namespace has been renamed from \:sequin\_stream\ to \:sequin\ across all environment files (config, dev, test, prod). This change aligns the configuration keys with the new application name, updating all relevant module references such as \SequinStream.Repo\ to \Sequin.Repo\ and \SequinStreamWeb.Endpoint\ to \SequinWeb.Endpoint\ in the configuration files.

config · high confidence

The codebase introduces a new routing mechanism for sink connectors, replacing the previous \ConsumerRecord\-based approach with a structured \RoutedConsumer\ behavior. This adds a \Helpers\ module for shared utilities, a \RoutedMessage\ wrapper for transformed messages, and a central \Routing\ module that dispatches messages to specific sink handlers (e.g., AWS SNS, Kinesis, Kafka, Redis, etc.). The \Validator\ module enforces compile-time checks to ensure all routing modules implement the required callbacks, providing stricter validation and a more explicit schema definition for routing data.

lib/sequin/runtime/routing · high confidence

The Functions index and edit pages have been redesigned with a new UI, including a table-based list view and an improved editor. A key behavioral change is that function code and type selections are now persisted in the browser's local storage, allowing users to recover their work if the page is refreshed or navigated away from. Additionally, the test message editor now supports inline editing of message fields, with changes saved to local storage.

assets/svelte/functions · high confidence

The SlotProducer pipeline has been restructured into a three-stage GenStage pipeline consisting of a SlotProducer (producer), multiple Processor partitions (consumers), and a ReorderBuffer (final consumer). This introduces new modules for managing batch state, batch markers, and relation schema caching, while the default callback implementations for flushing batches and handling connection failures are now provided by the PipelineDefaults module.

_lib/sequin/runtime/slot\producer · high confidence

The Redis sink implementation has been refactored to use a new \Sequin.Sinks.Redis.Client\ module backed by \eredis\ and \eredis\_cluster\, replacing the previous \Redix\-based approach. This change introduces a \ConnectionCache\ to manage and pool Redis connections, improving performance by avoiding repeated connection startups. The refactoring also adds improved error handling for timeouts and connection failures, and supports both Redis Stream and String sink types with specific command handling for each.

lib/sequin/sinks/redis · high confidence

The mailer module for the SequinStream application has been removed from the codebase. This eliminates the Swoosh mailer integration previously defined in lib/sequin\_stream/mailer.ex.

_lib/sequin\stream · high confidence

The Change Capture Pipelines feature has been renamed to Change Retention. This includes updating the page title, header, and all user-facing copy within the Svelte components in the \wal\_pipelines\ directory to reflect the new terminology.

_assets/svelte/wal\pipelines · high confidence

The application and its associated modules have been renamed from SequinStream to Sequin. This includes renaming the main library module (lib/sequin.ex), the web interface module (lib/sequin\_web.ex), and the console logger (lib/console\_logger.ex). The old lib/sequin\_stream.ex file was removed, and lib/sequin\_stream\_web.ex was renamed to lib/sequin\_web.ex, updating all internal references to use the new module names.

lib · high confidence

The web layer is renamed from SequinStream to Sequin, updating module names, OTP app names, and static file paths. The UserAuth plug is enhanced to support user impersonation, allowing admins to act as other users. A new LiveHelpers module provides utility functions for retrieving the current user and account, accounting for impersonation. Additionally, the Telemetry module is updated to report metrics for sink consumers and entity health, and the MetricsEndpoint is introduced to expose Prometheus metrics with optional basic auth.

_lib/sequin\web · high confidence

The GCP Pub/Sub sink configuration and display components have been restructured into dedicated Svelte files (icon, card, and form) to support new routing features, including dynamic topic selection and a link to the GCP Console. Simultaneously, the Sequin Stream sink UI has been reorganized into separate icon, card, and form components, with the card now displaying cURL examples for receiving and acknowledging messages.

_assets/svelte/sinks/gcp\pubsub · high confidence

The logger now automatically redacts sensitive information from log entries. A new \Sequin.Logger.Redactor\ module has been added to strip or mask specific keys (such as passwords, API keys, and tokens) from the metadata in JSON log entries, ensuring that sensitive data is not exposed in logs.

lib/sequin/logger · medium confidence

The main stylesheet was replaced to use Tailwind CSS directives (@tailwind) instead of the previous @import statements. A large set of CSS custom properties was added, defining a full color palette (including Carbon, Matcha, Breeze, Ruby, Honey, Blush, and Purplehaze themes) and semantic tokens for backgrounds, borders, and foregrounds. This establishes a consistent visual language for the application's UI components.

assets/css · high confidence

The frontend build process has been updated to support Svelte, introducing a new build pipeline via \build.js\ that compiles client and server bundles using esbuild, Svelte, PostCSS, and Tailwind CSS. Additionally, a set of reusable UI components (Accordion, Select) from the Shadcn-Svelte library has been added to the \assets/svelte\ directory, and the Tailwind configuration has been expanded to include new color palettes and theme variables.

assets · medium confidence

The example code in the Ecto seeds script has been updated to reflect the project rename from 'SequinStream' to 'Sequin', ensuring that the commented-out example code matches the actual module names in the application.

priv/repo · high confidence

Add comprehensive test schema for Postgres types and WAL events; Add end-to-end integration tests for Kafka and SQS destinations; Added automated tests for user authentication and account management flows; Added comprehensive test coverage for core API controllers; Added integration and unit tests for the SlotProducer pipeline; Added test support models for replication scenarios; Added tests for Postgres value casting, array parsing, and benchmark source; Added tests for backfill, HTTP push, and SNS sink consumers; Added tests for changeset deserialization and sink consumer validation; Added tests for entity health metrics and metrics store; Added tests for the BenchmarkPipeline sink; Added tests for the VerifyApiToken plug; Added tests for user authentication logic; Consolidates test infrastructure and assertions; Expanded test coverage for account management, AWS sinks, and runtime pipelines; Expanded test factories and support types for testing.

This change introduces the \assets/\ directory with a \package.json\ and \package-lock.json\ to manage frontend dependencies (including Svelte, Tailwind, and CodeMirror) and the \cli/\ directory with \go.mod\ and \go.sum\ to manage the Go-based CLI tool. Additionally, example projects for Elixir (\examples/elixir\_broadway/\) and TypeScript/Node.js (\examples/sequin-cdc-to-temporal/\, \examples/user-specific-webhooks/\) are added with their respective dependency manifests (\mix.exs\, \package.json\), establishing the new project layout.

(dependencies) · high confidence

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

• CAI 39 → 50 (+10.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 83 → 85 (+1.2)
• Architecture 55 → 60 (+4.3)
• Maturity 79 → 77 (-2.1)
• Readiness 34 → 42 (+8.2)
• Security 30 → 51 (+21.5)
• Accessibility 53 → 52 (-1.0)

• Change coupling: Edit.svelte ↔ edit.ex (assets/svelte/functions/Edit.svelte)
• Change coupling: Edit.svelte ↔ routing.ex (assets/svelte/functions/Edit.svelte)
• Change coupling: Index.svelte ↔ edit.ex (assets/svelte/functions/Index.svelte)
• Change coupling: dynamicRoutingDocs.ts ↔ edit.ex (assets/svelte/consumers/dynamicRoutingDocs.ts)
• Change coupling: dynamicRoutingDocs.ts ↔ routing.ex (assets/svelte/consumers/dynamicRoutingDocs.ts)
• Change coupling: routing_function.ex ↔ routing.ex (lib/sequin/consumers/routing_function.ex)
• Change coupling: types.ts ↔ routing.ex (assets/svelte/consumers/types.ts)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (cli/go.mod)
• Critical IaC: AWS-0104 (deployment/terraform-ecs-ec2-sqs/infra/sg.tf)
• Critical IaC: AWS-0104 (deployment/terraform-ecs-ec2/infra/sg.tf)
• Critical IaC: AWS-0104 (deployment/terraform-ecs-fargate/infra/sg.tf)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (lib/sequin/consumers/filter_function.ex)
• Duplicated block (10 lines × 2) (lib/sequin/key.ex)
• Duplicated block (10 lines × 3) (lib/sequin/sinks/s2/client.ex)
• Duplicated block (10 lines × 4) (lib/sequin/sinks/kafka/connection_cache.ex)
• Duplicated block (11 lines × 2) (lib/mix/tasks/bench.ex)
• Duplicated block (11 lines × 2) (lib/sequin/replication/replication.ex)
• Duplicated block (11 lines × 2) (lib/sequin/runtime/slot_message_store.ex)
• …and 129 more

• Change coupling: FullPageForm.svelte ↔ consumer_form.ex (assets/svelte/components/FullPageForm.svelte)
• Change coupling: FullPageForm.svelte ↔ router.ex (assets/svelte/components/FullPageForm.svelte)
• Change coupling: Index.svelte ↔ consumers.ex (assets/svelte/functions/Index.svelte)
• Change coupling: KafkaSinkCard.svelte ↔ KafkaSinkForm.svelte (assets/svelte/sinks/kafka/KafkaSinkCard.svelte)
• Change coupling: KafkaSinkForm.svelte ↔ kafka_sink.ex (assets/svelte/sinks/kafka/KafkaSinkForm.svelte)
• Change coupling: ShowMessages.svelte ↔ acknowledged_message.ex (assets/svelte/consumers/ShowMessages.svelte)
• Change coupling: consumer_event_data.ex ↔ message_handler.ex (lib/sequin/consumers/consumer_event_data.ex)
• Change coupling: home_live.ex ↔ router.ex (lib/sequin_web/live/home_live.ex)
• Change coupling: http_push_pipeline.ex ↔ redis_stream_pipeline.ex (lib/sequin/runtime/http_push_pipeline.ex)
• Change coupling: prod.exs ↔ runtime.exs (config/prod.exs)
• Change coupling: redis_stream_pipeline.ex ↔ sqs_pipeline.ex (lib/sequin/runtime/redis_stream_pipeline.ex)
• Change coupling: types.ts ↔ kafka_sink.ex (assets/svelte/consumers/types.ts)
• Change-coupling hub: edit.ex → dynamicRoutingDocs.ts, Edit.svelte, Index.svelte (lib/sequin_web/live/functions/edit.ex)
• Change-coupling hub: routing.ex → dynamicRoutingDocs.ts, types.ts, Edit.svelte, routing_function.ex (lib/sequin/runtime/routing/routing.ex)
• Client.connectionLoop (cognitive 20) (cli/chisel/client/client_connect.go)
• ConfigCommands.planAction (cognitive 23) (cli/cli/config_command.go)
• ConfigCommands.planAction (cyclomatic 18) (cli/cli/config_command.go)
• Critical CVE: [GHSA redacted] (cli/go.mod)
• Critical IaC: AWS-0104 (deployment/terraform-ecs-ec2-sqs/infra/sg.tf)
• Critical IaC: AWS-0104 (deployment/terraform-ecs-ec2-sqs/infra/sg.tf)
• …and 479 more

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

sequinstream/sequin 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.