softwaremill/elasticmq

ElasticMQ is a local, SQS-compatible message queue server that faithfully replicates Amazon SQS behavior, including FIFO queue support with deduplication and ordering, dead-letter queues, and long-polling. It provides a robust backend built on Apache Pekko and Scala, supporting both in-memory and persistent storage via file or SQL backends. The system exposes a standard SQS REST API compatible with AWS SDKs and includes a modern Next.js web UI for monitoring and managing queues.

18 changes.

The project migrated its backend infrastructure from Akka to Apache Pekko and upgraded to Scala 3, while restructuring the codebase into modular components. This period also introduced comprehensive support for Amazon SQS features, including FIFO queues, message deduplication, and dead-letter queue handling, alongside a new Next.js web UI.

10 changes.

The project migrated its core infrastructure from Akka to Apache Pekko, updating build dependencies and server configurations to support the new runtime. This period also saw the introduction of a new Next.js-based web interface for queue management and the addition of AWS SQS JSON Protocol support alongside enhanced FIFO queue features.

7 changes.

The project refactored file and SQL persistence layers to correctly handle queue dependencies, dead-letter queues, and FIFO configurations, ensuring robust metadata persistence. Concurrently, extensive integration test suites were added for Node.js and Python clients, and existing Java tests were restructured to cover new features and edge cases like race conditions and restart scenarios.

A new configuration file for ElasticMQ has been added to the Docker server setup. This file includes the standard application configuration, enabling the message queue service to operate correctly within the containerized environment.

server/docker · high confidence

The examples directory now includes an elasticmq.conf file that demonstrates how to configure the service with specific settings such as binding ports, JDBC storage URIs, and queue definitions including dead-letter and FIFO queues, along with an auto-create-queues template. Additionally, a logback.xml file has been added to provide a default logging configuration that outputs debug-level messages to the console.

examples · high confidence

A new Next.js-based web interface is introduced for ElasticMQ, enabling users to create, delete, and monitor message queues with a modern, responsive design. The UI supports both local ElasticMQ instances and real AWS accounts, configurable via environment variables, and includes an automatic 1-second state refresh feature (controllable via the NEXT\_PUBLIC\_AUTO\_REFRESH\_DISABLED flag) to keep queue statistics current. Users can send and generate messages, view detailed queue attributes, and manage FIFO queues with content-based deduplication options, all within a theme-aware layout featuring light and dark modes.

ui · high confidence

A new JMX MBean interface (QueuesMetricsMBean) and its implementation (QueuesMetrics) have been added to expose queue statistics via JMX. This includes metrics for the number of visible, invisible, and delayed messages per queue, as well as a tabular view of all queues. The implementation uses a cached thread pool for execution and interacts with the queue manager actor via Pekko messages to retrieve the data.

core/src/main/scala/org/elasticmq/metrics · high confidence

The repository has been reorganized to include a new Next.js-based web UI for monitoring and managing queues, alongside a comprehensive project documentation file (CLAUDE.md) detailing the backend (Pekko/Scala) and frontend (Next.js/TypeScript) architectures. Configuration and tooling have been updated: the code formatter is set to scalafmt 3.11.5 with Scala 2.13 dialect, and dependency management is controlled via .scala-steward.conf which pins logback and Scala 3 library versions while ignoring AWS SDK updates. Docker workflows are supported by a new docker-compose.yaml for running the server and UI together, along with .dockerignore and .gitignore files to exclude build artifacts and sensitive environment variables.

(repo-wide) · high confidence

The core server startup orchestration (ElasticMQServer) and its configuration model (ElasticMQServerConfig) have been relocated into the rest-sqs module. This change consolidates the server bootstrap logic, including the initialization of the ActorSystem, queue persistence setup, and REST SQS server binding, within the module responsible for the SQS interface. Users will see this as a structural reorganization of the codebase; the functional behavior of starting the server and loading configuration remains consistent, but the internal packaging of these components is now specific to the rest-sqs area.

rest/rest-sqs/src/main/scala/org/elasticmq/server · high confidence

The actor reply system in the core module has been refactored to allow actors to optionally choose whether to send a reply. A new \ReplyAction\ trait with \ReplyWith\ and \DoNotReply\ cases replaces the previous implicit-reply pattern, enabling \ReplyingActor\ implementations to explicitly suppress responses when needed. This change is part of the broader migration to Apache Pekko and Scala 3 compatibility.

core/src/main/scala/org/elasticmq/actor/reply · high confidence

The native server build now includes Java classes that provide GraalVM native-image substitutions for the Scala runtime. Specifically, a new \ScalaSubstitutions\ class replaces \scala.runtime.Statics.releaseFence\ with a direct call to \UnsafeUtils.UNSAFE.storeFence()\, and \UnsafeUtils\ provides access to \sun.misc.Unsafe\ via reflection. These changes enable the Scala library's memory fence operations to function correctly when the server is compiled to a native image.

native-server/src/main/java · high confidence

This change introduces a comprehensive set of new domain classes and validation logic within the core module to better align with Amazon SQS behavior. It adds support for FIFO queue features, including message deduplication (via SHA-256 hashing of message bodies and a 5-minute history window), message grouping, and sequence numbers. It also introduces Dead Letter Queue (DLQ) support with redrive capabilities, mirror queues (copyTo/moveTo), and binary message attributes. Additionally, it enforces strict SQS limits (such as 1MB max message size and 10 message attributes) and adds validation for queue names, message bodies, and receipt handles, while introducing a new error handling framework (ElasticMQError) and tracing ID support.

core/src/main/scala/org/elasticmq · high confidence

The server entry point now logs the application version during startup, providing immediate visibility into the running instance. Additionally, a shutdown hook has been added to ensure the server stops gracefully when the process receives a termination signal, logging the start and stop events for better operational monitoring.

server/src/main/scala · high confidence

The SQS REST module now uses Apache Pekko instead of Akka, reflected in the new application.conf and reference.conf files. To ensure compatibility with Amazon SQS clients, the HTTP server request timeout is set to 21 seconds (accommodating the 20-second long-polling maximum) and the maximum URI length is increased to 256KB. Additionally, illegal header warnings are suppressed to handle SQS authentication headers, and default node binding is configured for port 9324.

rest/rest-sqs/src/main/resources · high confidence

The native server's application configuration now includes a Pekko library-extensions setting and enables SSL by default, reflecting the migration from Akka to Pekko.

native-server/src/main/resources · medium confidence

The internal message-passing protocol in the core actor system has been restructured to support new queue management and message movement capabilities. New message types allow updating queue metadata such as visibility timeout, delay, receive wait time, tags, and the dead-letter queue configuration. The protocol now explicitly supports moving messages to a dead-letter queue (DLQ) via a \MoveMessage\ command and managing background message move tasks through \StartMessageMoveTask\, \CancelMessageMoveTask\, and related handles. Additionally, the \ReceiveMessages\ command now accepts a \waitForMessages\ parameter and a \receiveRequestAttemptId\, and the system includes logic for deduplication ID cleanup.

core/src/main/scala/org/elasticmq/msg · high confidence

The REST SQS directive layer has been restructured into modular traits (AWSProtocolDirectives, AnyParamDirectives, ExceptionDirectives, etc.) to support the AWS JSON Protocol 1.0 alongside the existing query protocol. This change introduces specific handling for JSON requests, including extracting the action from the X-Amz-Target header and supporting X-Amzn-Trace-Id for tracing. Error responses are now protocol-aware: JSON protocol errors include the X-Amzn-Query-Error header and JSON body, while query protocol errors continue to use XML. Queue name and URL extraction logic has been consolidated to handle context paths and account IDs more robustly across both protocols.

rest/rest-sqs/src/main/scala/org/elasticmq/rest/sqs/directives · high confidence

The file persistence logic has been restructured into three new classes: ConfigBasedQueuePersistenceActor, QueueConfigUtil, and QueuePersister. This change introduces proper queue name validation (including automatic .fifo suffixes for FIFO queues) and ensures that queue configurations are sorted after loading to handle dependencies like dead-letter queues correctly. It also fixes issues where delay and receiveMessageWait settings were not properly loaded from persisted queue configurations, and adds error logging when queue configuration extraction fails.

persistence/persistence-file/src/main · high confidence

The queue actor implementation has been restructured into modular traits (QueueActorMessageOps, QueueActorQueueOps, QueueActorWaitForMessagesOps) to separate message handling, queue management, and long-polling logic. This refactor introduces native support for FIFO queues, including message ordering via orderIndex, deduplication history management, and a new ReceiveRequestAttemptCache to handle request retries and attempt IDs. Long-polling behavior is improved with a dedicated waiting mechanism that schedules replies when messages become available, and the system now supports Dead Letter Queues (DLQ) with configurable redrive actions and message copying/moving between queues.

core/src/main/scala/org/elasticmq/actor/queue · high confidence

The queue management logic in the core actor package has been restructured into three distinct components: QueueManagerActor, QueueManagerActorStorage, and QueueManagerMessageOps. QueueManagerActor now handles high-level queue lifecycle operations (create, delete, lookup, list) and delegates specific behaviors to traits. QueueManagerActorStorage provides the shared context and timeout configuration for managing the map of queue actors. QueueManagerMessageOps encapsulates the logic for starting, tracking, and canceling message move tasks between queues, including the ability to identify dead-letter queue sources. This refactoring isolates concerns, making the queue manager more maintainable and easier to extend.

core/src/main/scala/org/elasticmq/actor · high confidence

The message handling logic in the queue actor has been split into separate traits (such as DeleteMessageOps, MoveMessageOps, and SendMessageOp) to improve code organization. For FIFO queues, the system now enforces message deduplication by tracking message deduplication IDs; duplicate messages are rejected or handled according to the history, and when messages are moved to a Dead Letter Queue, the message ID is assigned as the deduplication ID. Additionally, sequence numbers for FIFO messages are now generated within the queue actor rather than the REST layer to align with AWS behavior, and the visibility timeout calculation has been centralized in CommonOperations.

core/src/main/scala/org/elasticmq/actor/queue/operations · high confidence

The SQL persistence layer now correctly persists and restores queue metadata for dead-letter queues, copy-to destinations, and move-to destinations. This change introduces a topological sort to ensure that referenced queues (such as dead-letter queues) are created before the queues that depend on them, preventing initialization errors when queue dependencies are present. It also adds a new \deadLetterSourceQueueName\ field to message persistence to track the source queue for messages moved to a dead-letter queue.

persistence/persistence-sql · high confidence

The SQS REST interface has been refactored to use Apache Pekko instead of Akka, introducing new modules for actor system management, attribute handling, and batch request processing. The monolithic directive structure has been split into individual, focused directive files (e.g., CreateQueueDirectives, DeleteMessageDirectives) and a centralized Action enumeration, improving code organization and maintainability while preserving the existing SQS-compatible API surface.

rest/rest-sqs/src/main/scala/org/elasticmq/rest/sqs · high confidence

The SQS REST module now supports the AWS JSON Protocol 1.0 alongside the existing query-based protocol, allowing clients to send requests using JSON payloads. This change introduces new model classes to handle JSON request parsing and marshalling via Pekko HTTP. Additionally, the Redrive Policy implementation has been updated to explicitly parse and output the \region\ and \accountId\ fields from the \deadLetterTargetArn\, replacing the previous backward-compatible format that relied on optional or implicit values. This ensures that ARN-based redrive policies are handled with full fidelity to the AWS specification.

rest/rest-sqs/src/main/scala/org/elasticmq/rest/sqs/model · high confidence

Added MutableNowProvider test utility; Added actor-level tests for queue operations, deduplication, and event listeners; Added local performance test for REST SQS and in-memory modes; Added test configuration files for SQS testing; Added test coverage for SQS REST module components; Added test infrastructure for ElasticMQ actor tests; Added test utility helpers for timing and temporary directory management; Added tests for FIFO message ordering and receive request attempt caching; Added tests for delivery receipts, FIFO deduplication history, and queue limits; Added tests for file-based queue configuration persistence; New Node.js and Python integration test suites with Docker support; Refactored SQS integration test infrastructure and added new test coverage.

The core utility layer has replaced Joda Time dependencies with the standard Java 8 \java.time\ API. This is implemented via new \NowProvider\ and \OffsetDateTimeUtil\ classes that use \OffsetDateTime\ and \Instant\, ensuring consistent time handling across the application without external legacy libraries.

core/src/main/scala/org/elasticmq/util · high confidence

The build configuration (build.sbt) has been updated to use Apache Pekko 1.7.0 and Pekko HTTP 1.4.0 (migrated from Akka), along with Scala 2.12.20, 2.13.18, and 3.3.7. Other Scala dependencies such as pureconfig (0.17.8), scalikejdbc (4.3.5), and H2 (2.2.224) have also been updated. Additionally, new dependency manifests have been added for Node.js integration tests (using @aws-sdk/client-sqs 3.990.0, Jest, and testcontainers) and the UI module (using Next.js 16.1.6, React 19.2.3, and Vitest), establishing the dependency baseline for these new 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 39 → 49 (+9.9)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 65 → 69 (+3.3)
• Architecture 69 → 96 (+27.0)
• Maturity 61 → 65 (+3.5)
• Readiness 21 → 39 (+17.8)
• Security 46 → 70 (+24.0)
• Accessibility 44 (new)

• Critical CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• Critical CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• Critical IaC: DS-0031 (ui/Dockerfile)
• Critical IaC: DS-0031 (ui/Dockerfile)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (integration-tests/nodejs/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• …and 77 more

• Change coupling: QueueActorMessageOps.scala ↔ QueueActorQueueOps.scala (core/src/main/scala/org/elasticmq/actor/queue/QueueActorMessageOps.scala)
• Concentrated knowledge decay
• Coverage not measured — JavaScript/TypeScript suite
• Critical IaC: DS-0031 (ui/Dockerfile)
• Critical IaC: DS-0031 (ui/Dockerfile)
• Critical vulnerability: [GHSA redacted] (ui/package-lock.json)
• FunctionTooLong: create-queue-modal.CreateQueueModal (ui/components/create-queue-modal.tsx)
• FunctionTooLong: generate-messages-modal.GenerateMessagesModal (ui/components/generate-messages-modal.tsx)
• FunctionTooLong: queue-card.QueueCard (ui/components/queue-card.tsx)
• FunctionTooLong: queue-details.QueueDetails (ui/components/queue-details.tsx)
• FunctionTooLong: queue-list.QueueList (ui/components/queue-list.tsx)
• FunctionTooLong: receive-messages-panel.MessageCard (ui/components/receive-messages-panel.tsx)
• FunctionTooLong: receive-messages-panel.ReceiveMessagesPanel (ui/components/receive-messages-panel.tsx)
• FunctionTooLong: send-message-modal.SendMessageModal (ui/components/send-message-modal.tsx)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• High CVE: [GHSA redacted] (ui/package-lock.json)
• …and 91 more

• 8 commits — 8 feature/other, 0 fixes

• (root) — 3 commits
• project/plugins.sbt — 3 commits
• project/build.properties — 2 commits

• change: Update jcl-over-slf4j to 2.0.19 (#1251)
• change: Update jcl-over-slf4j to 2.0.20 (#1255)
• change: Update pekko-actor, pekko-slf4j, ... to 1.7.0 (#1244)
• change: Update sbt, scripted-plugin to 1.12.15 (#1241)
• change: Update sbt, scripted-plugin to 1.13.0 (#1245)
• change: Update sbt-assembly to 2.4.2 (#1243)
• change: Update sbt-assembly to 2.5.0 (#1248)
• change: Update sbt-git to 2.2.0 (#1252)

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

softwaremill/elasticmq 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.