Apache ActiveMQ
A message broker written in Java. It supports JMS, OpenWire, AMQP, MQTT and STOMP clients, with queues, topics, persistent stores, security plugins and networks of brokers. Maintained by the Apache Software Foundation.
Business rules, traced to source lines.
These 12 rules are a sample of the 29,404 CoreStory V3 extracted from Apache ActiveMQ. Each one links to the exact lines on GitHub at commit 429e56e. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.
When a SystemUsage is lazily created, the memory usage limit is set to 1024L * 1024 * 1024 * 1 (1 GB), the temp usage limit to 1024L * 1024 * 1024 * 50 (50 GB), the store usage limit to 1024L * 1024 * 1024 * 100 (100 GB), and the job scheduler usage limit to 1024L * 1024 * 1024 * 50 (50 GB).
- 1 bytes — memory usage multiplier giving 1 GB
- 50 bytes — temp usage multiplier giving 50 GB
- 100 bytes — store usage multiplier giving 100 GB
- 50 bytes — job scheduler usage multiplier giving 50 GB
When send failure options do not apply, the producer exchange is marked as blocking on flow control, blocked sends are incremented, and the usage is polled every 1000 ms until space is available; if the connection is stopping, an IOException is thrown.
- 1000 milliseconds — polling interval for waitForSpace when blocking
When a matching RedeliveryPolicy is found and the max redelivery count is exceeded, if sendToDlqIfMaxRetriesExceeded is true (the default) the message is sent to the dead letter queue via super.sendToDeadLetterQueue; if false, the message is discarded and only a debug log is emitted.
- true — default value of sendToDlqIfMaxRetriesExceeded
Also cited: L58
When previousDelay > 0, useExponentialBackOff is true, and backOffMultiplier > 1, the next delay is previousDelay multiplied by backOffMultiplier truncated to a long; if maximumRedeliveryDelay is not -1 and the computed nextDelay exceeds maximumRedeliveryDelay, nextDelay becomes the greater of maximumRedeliveryDelay and redeliveryDelay.
- 0 — lower bound for previousDelay to enable exponential back off
- 1 — lower bound for backOffMultiplier to enable exponential back off
- -1 — sentinel indicating no maximum redelivery delay
When a message sent to the DLQ is not persistent, it is made persistent and property "originalDeliveryMode" is set to "NON_PERSISTENT".
- originalDeliveryMode — property recording original delivery mode
- NON_PERSISTENT — value stored for original delivery mode
If the computed timeToLive is greater than zero and ttlCeiling is greater than zero and timeToLive exceeds ttlCeiling, timeToLive is capped to the value of ttlCeiling.
- 0 — threshold above which the ceiling comparison applies
Also cited: L64
send checks the security context of the producer exchange connection; for non-broker contexts whose authorized write destinations do not already contain the message destination, it computes write ACLs, throws SecurityException "User <userName> is not authorized to write to: <destination>" when the ACL set is non-null and the context is not in one of those ACLs, and otherwise records the destination before delegating to the next broker.
If a connection with the same clientId already exists and the new context does not allow link stealing, adding the connection is rejected with InvalidClientIDException with the message "Broker: " + brokerName + " - Client: " + clientId + " already connected from " + old remote address; if link stealing is allowed, the clientIdSet entry is replaced.
- Broker: — prefix of duplicate-client-id exception message
- - Client: — separator in duplicate-client-id exception message
- already connected from — suffix of duplicate-client-id exception message
When temp destination stealing is not allowed and the subscribing consumer's connection ID differs from the temporary topic's owning connection ID, addSubscription throws an InvalidDestinationException with the message "Subscribing to a temporary topic created by another connection is not permitted".
- false — default value of allowTempDestinationStealing that triggers the check
- Subscribing to a temporary topic created by another connection is not permitted — exception message
Also cited: L37
A scheduled message's repeat value must not exceed maxRepeatAllowed (default 1000); if the converted repeat value is greater than maxRepeatAllowed, a MessageFormatException with the message "The scheduled repeat value is too large" is thrown.
- 1000 — default maximum allowed repeat count
When abortSubscriberConnection is true, the strategy aborts the whole connection by scheduling a serviceException with an InactivityIOException carrying the number of slow consumers and the maxSlowCount and maxSlowDuration values, with a delay of 0.
- 0 milliseconds — scheduled delay before aborting the connection
The TRACE HTTP method is disabled by default (Cross-Site Tracing protection). By default a FORBIDDEN constraint on method TRACE at path spec "/" is registered, yielding 403; when explicitly enabled it is ALLOWED.
- false — default enableTrace value
- TRACE — constrained HTTP method
- / — path spec
Also cited: L144
What the application does
25 capabilities identified, grouping 154 of the 6,087 distinct features extracted. Most extracted features are not grouped under a capability, so this list is a partial view of the application. These are descriptions, not the cited rules above.
Wire-Format Marshalling and Serialization
Serializing and deserializing messages, commands, and data structures to and from loose and tight binary wire formats.
- ActiveMQ Message Marshalling: Serializes and deserializes ActiveMQ text messages using loose and tight wire formats.
- ActiveMQ Object Marshalling: Converts ActiveMQ temp topic objects to and from the wire format via loose and tight marshal/unmarshal routines.
- Command Marshalling: Encode and decode command objects into a wire/byte format for transmission between systems.
- Command Marshalling and Unmarshalling: Serializes commands to a wire format and reconstructs them, supporting both loose and tight encodings for the last partial command.
- Control Command Marshalling: Encapsulates marshalling of OpenWire control commands for transport over the wire.
- Loose Marshalling: Support for serializing objects using a flexible, self-describing loose wire format with version negotiation.
- Loose Marshalling/Unmarshalling: Serialize and deserialize response data using the loose encoding scheme.
- Loose Object Marshalling: Serialize and deserialize objects using the loose (flexible) wire format for inter-system data exchange.
- Loose Object Serialization: A flexible serialization mode that marshals and unmarshals objects, strings, byte arrays, sequences, longs, nested objects, cached objects, and throwables to and from a loose wire format.
- Loose Wire Format Marshalling: Serializes data structures into the loose wire format and deserializes them back, used to exchange payloads over the transport.
- Message Marshalling: Capability to convert between AMQP wire frames and application-level objects via pluggable transformer marshalling and unmarshalling.
- Message Marshalling and Unmarshalling: Serializes and deserializes ActiveMQ messages for wire transmission using loose and tight (versioned, two-pass) encoding schemes, along with message object construction.
- Message Marshalling/Unmarshalling: Serializes and deserializes message/topic objects between tight and loose wire formats.
- Message Serialization: Serializes and deserializes messages in loose and tight wire formats for transport.
- Message Serialization and Deserialization: A capability to encode and decode messages in both compact ('tight') and flexible ('loose') binary wire formats with size accounting.
- Object Marshalling: Marshals and unmarshals objects between loose and tight binary wire formats for transmission or storage.
- Object Marshalling and Unmarshalling: Serializes and deserializes objects to and from wire format for transport.
- Object Marshalling/Serialization: Serializes and deserializes application objects to and from a transported representation using loose and tight marshalling strategies.
- Object Marshalling/Unmarshalling: Serializes and deserializes objects into tight or loose binary wire formats for transport.
- Object Serialization: Serializes and deserializes objects in loose and tight wire formats for transport.
- Object Serialization & Deserialization: Serializes and deserializes objects to/from wire format with loose and tight marshalling variants.
- Object Serialization and Deserialization: The capability to marshal and unmarshal object data structures into and out of a wire format.
- Object Serialization/Marshalling: Serialize and deserialize application objects to and from a wire format for transport or storage.
- OpenWire Message Marshalling: Serialization and deserialization of OpenWire protocol commands/messages in both tight and loose wire formats for transport over the network.
- OpenWire Object Marshalling: Serialize and deserialize OpenWire protocol objects using loose and tight binary encoding formats.
- OpenWire Object Serialization: Encode and decode OpenWire wire-format objects through loose and tight marshalling paths.
- Tight Marshalling: Support for serializing objects using a compact, schema-planned tight wire format split across two passes and deserialized in one pass.
- Tight Marshalling/Unmarshalling: Serialize and deserialize response data using the tight encoding scheme with a two-phase marshal.
- Tight Object Marshalling: Serialize and deserialize objects using the tight (compact, versioned) wire format in a two-phase write and single-phase read.
- Tight Object Serialization: A compact two-phase serialization mode that marshals and unmarshals objects, strings, byte arrays, sequences, longs, nested objects, cached objects, and throwables to and from a tight wire format.
- Tight Wire Format Marshalling: Serializes data structures into a size-prefixed tight wire format using two-pass marshalling and deserializes them back.
- Wire Format Marshalling: Marshals messages between local and remote wire formats within the transport filter pipeline.
Broker Lifecycle Management
Creation, startup, configuration, restart, recovery, and shutdown of message broker instances across the system.
- Broker Container Lifecycle & Management: Provides the core broker container that holds the management context, security (SSL) context, and transport connectors, forming the runtime a user starts and manages.
- Broker Creation: Create and provision a broker instance through a factory-based handler.
- Broker Lifecycle: Spinning up and tearing down broker test instances with their generated resources.
- Broker Lifecycle Control: Starting, stopping, and reporting the running state of the broker and its services.
- Broker Lifecycle Management: The broker can be created, started, and stopped, with state tracked to reflect its lifecycle.
- Broker Region Lifecycle: The region can be started and stopped, managing its broker and task runner lifecycle.
- Broker Restart: Allows a running message broker to be restarted, preserving or reinitializing its state.
- Broker Setup and Teardown: A broker instance is created for a test and torn down afterwards, managing the broker lifecycle.
- Broker Shutdown: Stops running brokers, optionally all of them, through a shutdown command.
- Broker Start and Stop: Start and stop an AMQP broker instance for use in tests and runtime scenarios.
- Broker Start/Stop: Start and stop an embedded message broker for use by clients and tests.
- Broker Start/Stop Control: Ability to start and stop a message broker instance, with broker service and URL configuration.
- Broker Start/Stop Lifecycle: The broker can be started, torn down, and restarted with its persistence configuration and connection URI.
- Broker Startup: Boot a message broker with configured persistence so it begins accepting and servicing connections.
- Embedded Broker Lifecycle: Starts and stops an embedded message broker as the runtime environment for messaging tests.
- Embedded Broker Lifecycle Management: Allows the resource adapter to start and stop an embedded ActiveMQ broker, including broker XML configuration retrieval and updates.
- Graceful Broker Shutdown: Performs coordinated shutdown of the broker, connections, and waiting threads.
- Message Broker Lifecycle Control: Ability to control broker startup behavior, such as configuring whether the embedded broker starts automatically.
- Message Broker Lifecycle Management: Creating and running an embedded message broker service for producing and consuming messages.
- Programmatic Broker Creation: Create an embedded broker programmatically for testing or embedded use.
Message and Journal Persistence
Durable storage and recovery of messages and broker state via persistence adapters, journals, KahaDB, and JDBC stores.
- Checkpointing: Checkpoint operation that flushes persistent state to durable storage.
- JDBC Message Store: Persists and retrieves messages, message references, and subscriptions through a relational database adapter.
- Journal Lifecycle Management: Loads, starts and stops the message journal, exposes corruption checking, and allows tuning of journal file length, cleanup interval and write batch size.
- KahaDB Message Persistence: Provides a message store backed by KahaDB, including its supporting filesystem directory and broker service integration.
- Message Persistence: Storing, updating, removing, and counting messages in a durable message store.
- Message Persistence Store: A persistent message store (KahaDB) that brokers use to durably retain messages and content.
- Message Recovery: Recovering unacknowledged or lost messages back into a subscription when recovery is required.
- Message Recovery After Restart: Recovers prepared operations and undelivered messages, with priority-aware scanning, following a restart.
- Message Recovery from Reference: Recovers a full message from a lightweight message reference, deciding whether recovery can proceed and deduplicating the recovered result.
- Message Store Recovery: Recover the message store state and reload messages after restart.
- Message and Subscription Recovery: Recovers expired messages and pending messages for subscriptions after failures or restarts.
- Persistence Adapter: Provides the persistence layer used to store and retrieve messages, backed by the configured message store.
- Transaction Checkpointing: A capability that periodically checkpoints transaction state at a configured interval.
Queues, Topics, and Destination Management
Creating, naming, configuring, browsing, and removing queues, topics, temporary, composite, and virtual destinations.
- Composite Destination Messaging: Bridge messages across MQTT and JMS via composite topics and queues to verify end-to-end delivery.
- Destination Creation: Creates and caches destinations for use by callers.
- Destination Creation and Listing: Users can create and list broker destinations (queues and topics).
- Destination Creation and Lookup: Create or look up queues and topics, including temporary destinations.
- Destination Management: Getting and setting the link's destination address, allowing users to configure where the link sends or receives.
- Destination Registration: Registers destinations/consumers with the strategy so their consumption behavior can be monitored.
- JMS Destination Creation: Creating queue and topic destinations from the activation spec, including validation of destination name and destination type.
- Message Destination Management: Capability to add and manage message destinations for a broker.
- Queue Management: Create and delete message queues to define destinations for point-to-point messaging.
- Temporary Destination Creation: Creates and resolves temporary topic destination objects from wire data.
- Temporary Destination Management: Clients can create and delete temporary queues and topics for scoped messaging.
- Topic Management: Create and delete message topics to define destinations for publish-subscribe messaging.
- Virtual Destinations: Capability to define virtual destinations that map incoming destinations to one or more physical destinations for routing messages.
Transaction and XA Support
Beginning, preparing, committing, rolling back, and recovering local and XA distributed transactions.
- Login Transaction Commit: Commit or abort the authentication transaction, recording success and attaching the authenticated user to the subject.
- Message Transaction Management: Beginning, preparing, committing, rolling back, forgetting, and inspecting transactions on the broker.
- STOMP Transactions: Supports BEGIN/COMMIT/ABORT transactional framing so clients can group message operations atomically.
- Session Transaction Management: Commits, rolls back, or recovers a session's transacted message work.
- Transaction Commit: Committing a unit of work against the AMQP link so that its effects are durably applied.
- Transaction Lifecycle Management: Two-phase commit transaction processing allowing users to commit or roll back a unit of work with prepare state tracking.
- Transaction Management: Beginning, preparing, committing, rolling back, and forgetting message transactions, with tracking of prepared transactions.
- Transaction Rollback: Rolls back an operation, restoring state on failure.
- Transactional Messaging: Enlist message operations in local and XA transactions with associated transaction and session identity information.
- XA Distributed Transaction Support: Clients can execute XA distributed transactions including prepare, commit, and rollback against the broker.
- XA Transaction Management: Coordinates XA (distributed) transactions through their lifecycle of prepare, commit, and rollback phases.
- XA Transaction Support: Exposes XA exception generation for distributed transaction error handling.
Broker and Client Connection Management
Establishing, configuring, authenticating, tracking, and tearing down broker and client connections, including failover and reconnection.
- Automatic Reconnection: Recover a dropped transport connection when the transport supports it.
- Automatic Reconnection with Backoff: Automatically reconnect failed services using configurable initial delay, max delay, max attempts, and optional exponential backoff.
- Broker Connection Establishment: Creates and tears down connections and connection factories to a message broker for consuming messages.
- Broker Connection Management: Set up and tear down a broker and its connection factory/client for JMS interactions.
- Broker Connection Setup: A capability for establishing and configuring connections to a message broker, including acquiring connection URIs and managing direct and pooled connections.
- Connection Establishment: Establishes a connection to a target with an associated filter applied, letting users or systems initiate connectivity.
- Connection Failover and Reconnect: Automatically reconnects to alternate broker URIs when the active transport fails, with configurable reconnect delays, exponential backoff, and attempt limits.
- Connection Lifecycle Management: Start, stop, reconnect, and query the connection state of an in-VM transport link.
- Connection Management: Adding, tracking, and removing client connections to the broker, including administrative connection context.
- Messaging Connection Establishment: Opening and managing a client connection/session to the message broker.
- WebSocket Connection Lifecycle Management: A capability that manages the WebSocket connection lifecycle, including session tracking, orderly close timeouts, and handling stopped connections.
Message Production and Consumption
Producers send messages to destinations and consumers receive them synchronously, asynchronously, or via pull.
- Asynchronous Message Delivery: Allows messages to be added to queues and topics asynchronously so producers are not blocked.
- JMS Message Consumption: Clients can receive messages synchronously or asynchronously from queues and topics, including durable, exclusive, and retroactive consumers.
- JMS Message Production: Clients can send messages to queues and topics, including large, map, and anonymous messages, with synchronous and transactional send semantics.
- Message Consumption: Allows consumers to receive, pull, acknowledge, and discard messages from destinations.
- Message Production: Clients can produce and send messages to a destination, with producer registration, flow control, and flow-control warning behavior.
- Message Production and Consumption: Messages are produced to destinations and drained/consumed across multiple journal data files.
- Message Production and Sending: Sending messages to a broker over a transport URL, including to a test topic.
- Message Receiving: Consumes messages from a messaging destination in multiple formats (bytes, text, map, object) or as a generic message.
- Message Sending: Send messages over a network transport with send-buffer allocation and frame-size negotiation.
- Message Sending to Broker: A client can send a message to an ActiveMQ broker, with the message validated before dispatch.
Transport and Protocol Support
Network transports and wire protocols (TCP, NIO, SSL, UDP, VM, HTTP, WebSocket, OpenWire, AMQP, MQTT, STOMP) that carry messages between clients and brokers.
- AMQP Message Transport: Delivers messages over the AMQP protocol, including protocol conversion and wire-format handling with inactivity monitoring.
- HTTP Transport Server: Run an HTTP-based message transport server with pluggable wire format and transport options that other systems connect to for messaging.
- MQTT Transport: Provides an MQTT protocol transport that can be started and stopped to carry messages between MQTT clients and the broker.
- NIO Transport: Provides a non-blocking I/O transport implementation for network communication.
- SSL/TLS Transport: Provides SSL/TLS-secured broker transport by configuring SSL connectors and creating SSL transport servers.
- SSL/TLS Transport Connection: Establishes a peer-to-peer SSL/TLS connection with socket initialization and certificate retrieval for secure transport.
- STOMP Transport: Creates a STOMP protocol transport using the default wire format.
- TCP Transport: Creates and provides TCP client and server transports for network communication.
- UDP Transport: Provides message transport over the UDP protocol.
- WebSocket Transport: A bidirectional AMQP-over-WebSocket transport that connects, exchanges frames, delivers text/binary/closed events, and exposes remote address, subprotocol, wire format, and peer certificates.
Authentication
Authenticating clients to the broker via simple, JAAS, LDAP, certificate, SASL, JWT/OAuth2, and token-based mechanisms.
- Authentication: Enables users to authenticate against the broker via configured credentials and plugins.
- Certificate-Based Login: Authenticates users via X.509 client certificates by deriving the user name and group principals from the certificate.
- JAAS Authentication: Authenticates users via JAAS configuration and establishes a security context for principals.
- JWT Token Validation: Validate JWT tokens for signature, issuer, audience, expiry, and format before granting access.
- LDAP Authentication: Authenticate users against an LDAP directory by binding with their credentials and populating their subject.
- LDAP Authentication Configuration: Configures user credentials and anonymous access for authenticating to LDAP servers.
- OAuth2 Token Login: Authenticate a user by validating an OAuth2/JWT bearer token and establishing a login session.
- SASL Authentication: Authenticates a user by supplying credentials through a SASL mechanism and reporting the outcome.
- User Authentication: Authenticates connecting clients against configured user credentials.
Message Expiry, Redelivery, and Dead Letter Handling
Expiring messages by time-to-live, redelivering failed messages with policy, and routing undeliverable messages to dead letter queues.
- Dead Letter Handling: Routing of undeliverable messages to a dead letter queue.
- Dead Letter Queue Handling: Routes messages that cannot be delivered to a dead letter queue for later inspection.
- Dead Letter Queue Management: Identify and configure dead letter queue behavior, including duplicate-from-store handling and audit settings.
- Expired Message Handling: Enables brokers and consumers to expire and discard messages that exceed their time-to-live, including for durable subscribers, non-persistent messages, and slow consumers.
- Message Expiration: Periodically expires messages from destinations according to the configured expiration period and page size.
- Message Expiration Handling: Determines whether a message reference has expired and exposes its expiration time so the broker can discard stale messages.
- Message Redelivery: Schedules redelivery of messages with configurable delay policies and limits.
- Message Redelivery Policy: Configurable redelivery behaviour for failed messages, including delay, exponential back-off, and collision avoidance.
- Message Redelivery with Backoff Policy: Configurable redelivery of failed messages with exponential backoff, initial/maximum delays, and bounded or unbounded redelivery counts.
Authorization and Access Control
Controlling which users, groups, and network connections may access destinations and broker operations through ACLs, authorization maps, and plugins.
- Authorization: Controls which destinations and operations users are permitted to access.
- Authorization ACL Mapping: Provides role-based access control lookups that resolve read, write, and admin ACLs for destinations, including temporary destinations.
- Authorization Enforcement: Enforces access control by allowing or denying read, write, and temporary operations based on authorization checks.
- Authorization Map Management: Creation and management of authorization maps, including wildcard-based and temporary-destination-aware variants, that define which users and groups may access destinations.
- Authorization Policy Management: Defines and applies authorization entries, maps, and authentication plugins that control access to broker resources.
- Destination Authorization: Controls which destinations or operation types a client is permitted to access via configurable authorization entries.
- Network Connection Authorization: Determines whether network connections are allowed and whether authorization is required before accepting them.
Broker and Destination Configuration
Declaratively configuring brokers, destinations, policies, plugins, transports, and security through XML/XBean and beans.
- Broker Configuration: Declarative configuration of an ActiveMQ broker, including persistence, policy, memory/usage limits, and transport connectors.
- Broker Configuration Management: Dynamically add and remove broker transports and networks at runtime with or without JMX management.
- Broker Configuration and Startup: Configure a message broker instance together with its plugins and network settings.
- Broker Plugin Configuration: Attachment of plugins to the broker, such as JAAS authentication and runtime configuration plugins.
- Destination Policy Configuration: Configure destination behaviour such as DLQ, producer flow control, prioritized messages, caching, retroactive consumers, and audit limits.
- Transport Connector Configuration: Declaration of network transport connectors that expose the broker to clients.
- XBean Broker Configuration: Ability to start a broker configured through XBean XML, honoring protocol restrictions and allow/deny settings.
Durable Subscriptions
Creating, persisting, recovering, and unsubscribing durable topic subscriptions that survive disconnects and restarts.
- Durable Subscription: A topic subscription that persists across disconnection and can be restored to resume receiving messages.
- Durable Subscription Management: Clients can create and remove durable subscriptions.
- Durable Subscription Messaging: A capability to configure durable consumers for topic-based messaging.
- Durable Subscription Persistence: Provides a persistence adapter that stores durable subscriptions so they survive restarts, with validation of durable subscription keys.
- Durable Subscription Recovery: Recovers previously stored messages for durable subscriptions and signals whether recovery is required.
- Durable Topic Subscription: Creating a durable consumer subscription so messages survive disconnection.
- Durable Topic Subscription Messaging: Clients subscribe to a topic with a named durable subscription and receive or miss messages depending on their online/offline state, with the broker tracking abandoned subscriptions.
Management and Monitoring
Exposing broker, destination, connection, and statistic state via JMX and management views for administration and observability.
- Broker Destination Monitoring: Exposes runtime per-destination metrics (queue depth, enqueue/dequeue counts, message sizes, blocked/expired counts, memory and temp usage) for a broker destination.
- Broker JMX Management: Exposes and withdraws the runtime configuration broker as a manageable MBean for external administration.
- Broker Statistics Monitoring: Enable, disable, and reset broker statistics and report counts of connections, producers, consumers, messages, and destinations.
- Broker Statistics and Monitoring: Enable, disable, reset, and read broker runtime statistics such as message counts, connection counts, and consumer/producer totals.
- Connection Monitoring: Surfaces connection state and errors to the application through listeners and event callbacks.
- JMX Management: Register and unregister JMX MBeans for the broker, connectors, network connectors, and persistence adapters, and expose management views.
- Management Context: Exposes broker management context for administration.
Network of Brokers and Clustering
Bridging, clustering, discovery, and failover of multiple brokers so messages propagate across a broker topology.
- Broker Bridging: Establishing and awaiting network bridges between brokers so messages propagate across a multi-broker topology.
- Broker Bridging and Failover: Connects multiple message brokers together and forwards network failure notifications between them.
- Broker Cluster Failover: A multi-broker cluster is stood up and clients reconnect after broker failover and rebalance.
- Broker Cluster Management: Provision, remove, and tear down brokers in a cluster so clients can be connected to two, three, or a configurable number of brokers.
- Broker Network Bridging: Establishing connections between brokers to form a multi-broker network, as exercised by the TCP test harness.
- Broker Network Topology: Manage peer brokers, network bridges, and virtual destinations across the broker network.
- Network Bridge Management: Lifecycle notifications for network bridges connecting brokers.
SSL/TLS and Secure Transport
Configuring keystores, truststores, SSL contexts, cipher suites, and mutual TLS to secure broker and client connections.
- Keystore Configuration: Configures server and trust keystores with their type and password for secure connections.
- SSL Connector Configuration: Configure per-connector SSL context and transport options such as keystores, protocols, and client authentication.
- SSL Context Configuration: Builds and exposes a configurable SSLContext from protocol, provider, secure random, key managers, and trust managers.
- TLS Client Authentication: Users can control whether the secure connector requires or merely wants client authentication and configure the authentication credentials.
- TLS Key and Trust Store Configuration: Configures the key store and trust store (locations, types, passwords, and key passwords) used to establish SSL/TLS connections.
- TLS/SSL Handshake: Establishes secure TLS/SSL connections including handshake renegotiation support for TLSv1.2 and TLSv1.3.
- Trust Manager Management: Adds, sets, retrieves, and removes trust managers used to validate peer certificates.
Message Acknowledgement
Acknowledging and negatively acknowledging consumed messages across auto, client, individual, and transacted modes.
- Acknowledgement Configuration: Consumer acknowledgement behavior options including optimized acknowledgement and range ack control.
- Client Acknowledge Receive: Messages received under client-acknowledge mode are treated as delivered and can be recovered and redelivered when not acknowledged.
- Individual Message Acknowledgement: Acknowledging messages individually after the consumer has closed, verified in both sync and async modes.
- Message Acknowledgement: Processes acknowledgements for delivered messages.
- Message Acknowledgement Tracking: Tracks acknowledgement state for journaled messages via a dedicated messageAck element on the journal queue ack structure.
- Message Acknowledgment: Allows producers and consumers to exchange and acknowledge messages over AMQP and AMQ protocols.
Code and Artifact Generation
Generating source and supporting artifacts (marshalling code, schemas, licences, scaffolds) for the project.
- C++ Code Generation: Generates C++ source/header content from definitions, including type mapping, default values, and marshalling/unmarshalling method naming.
- Code Generation: Generates C# source files, factories, and supporting artifacts for marshalling from templates.
- Java Source Code Generation: Generates Java source files (bean/enum classes, accessors, equals, serialization, and other methods) from a protobuf descriptor, with support for single-file or multiple-file output and package/import handling.
- Licence Generation: Generates a project licence file for the scaffolded output.
- Protobuf Code Generation: Compiler components that consume the protobuf descriptor model to generate source code from proto definitions.
Message Selectors and Filtering
Filtering delivered messages using JMS selectors, XPath, and LIKE/wildcard expressions evaluated against message properties.
- JMS Message Selector Evaluation: A capability that evaluates JMS message selector expressions—supporting comparisons, equality, membership, null, LIKE with escape, string literals, identifiers, and delivery-mode checks—to determine whether a message matches a selector.
- Message Filtering: Applies expression-based filters to messages to selectively route or admit them through the broker.
- Message Selector: Capability to set and retrieve a selector for filtering which messages a consumer receives.
- Message Selector Filtering: Clients can attach a selector expression to a subscription so only messages matching the selector are delivered, with parsing and matching of the expression.
- XPath Message Selection: Select messages using XPath expressions against message content.
Prefetch and Flow Control
Tuning consumer prefetch windows and producer/consumer flow control to regulate message delivery under load.
- Consumer Prefetch Flow Control: Regulating message flow to consumers via configurable prefetch size and prefetch extension used for credit-based dispatch.
- Consumer Prefetch Management: Configure and update consumer prefetch size with in-flight and pending counters.
- Message Prefetch Policy Configuration: Configures consumer prefetch limits for queues, topics, durable topics, and queue browsers along with session args.
- Prefetch Policy Configuration: Clients can configure the prefetch policy used when consuming messages.
- Producer Flow Control: Throttles message-producing clients when a broker's flow control limits are reached, reporting blocked state and time spent blocked.
Resource Usage Limits and Memory Management
Configuring, tracking, and enforcing memory, store, temporary, and disk usage limits on the broker.
- Disk Usage Limit Enforcement: Cap storage consumption by tracking disk usage and ramping down when limits are exceeded.
- Memory Usage Management: Tracks and enforces memory usage limits for destinations and their cursors.
- Memory Usage Monitoring: The system reports memory usage as a percentage of the JVM heap and supports registering usage listeners that run on a background thread.
- Memory and Store Usage Limits: Configuration of system, store, memory, and temporary usage limits that govern broker resource consumption.
- Resource Usage Management: Configurable memory and store usage limits governing broker resource consumption.
Scheduling and Delayed Messages
Scheduling jobs and delivering messages after a delay, on a repeat, or on a cron schedule via the job scheduler.
- Cron Schedule Computation: Computes the next scheduled time for a cron expression based on current time and calendar fields.
- Delayed Message Sending: Ability to create and send messages that are delivered after a specified delay, via either a normal or anonymous producer.
- Job Scheduler Management: Access and configure the JMS job scheduler and its store limits.
- Job Scheduling: Register jobs with a scheduler and compute their upcoming execution times for dispatch.
- Scheduled Message Delivery: Delivering messages at a later time or on a recurring/cron schedule using delay, period, repeat, and cron properties.
Web Console and Web Application Hosting
Serving the administrative web console and web applications via embedded HTTP/HTTPS servers and servlets.
- Embedded HTTP Server: A Jetty server is embedded and configured to serve web applications from a deployment directory, allowing callers to run an HTTP server serving webapp contexts.
- Embedded Web Server Hosting: Hosts and serves a web application using an embedded Jetty server bound to a configured port and context.
- Web Console: Provides a browsable web console for managing and monitoring the broker.
- Web Console Configuration: Enable and configure the broker's web management component.
- Welcome Page Serving: Serves configured welcome files and optional favicon to clients.
Message Browsing
Inspecting queued messages without consuming them via browsers, paged views, and web console views.
- JMS Message Browsing: Allows a user to browse messages present on a JMS destination without consuming them.
- Message Browsing: Create a browser to inspect messages on a destination.
- Queue Browser Creation: Create a browser to inspect messages on a queue without consuming them.
- Queue Browsing: Allows a client to browse messages on a queue without consuming them, optionally with prefetch and transactional session support.
Duplicate Message Detection and Suppression
Detecting and suppressing duplicate messages and subscriptions to prevent redundant delivery.
- Duplicate Message Detection: Detects and removes duplicate messages using matching logic.
- Duplicate Message Suppression: Detects and removes duplicate subscriptions and controls whether message dispatch suppression and duplicate suppression are applied.
- Duplicate Queue Subscription Prevention: Ensures duplicate queue subscriptions are rejected and that subscription priority determines which consumer receives messages.
What was analyzed
- Java · 4,586 files · 464,932 lines
- Properties · 80 files · 200,899 lines
- JavaScript · 34 files · 17,911 lines
- Maven · 60 files · 11,415 lines
- XML · 303 files · 10,965 lines
- HTML · 86 files · 2,272 lines
- Bourne Shell · 8 files · 1,845 lines
- JSP · 29 files · 1,743 lines
- CSS · 14 files · 1,740 lines
- Markdown · 35 files · 1,487 lines
- SVG · 4 files · 1,372 lines
- Other (16 languages) · 95 files · 4,228 lines
Whole repository: 5,664 files. cloc 2.06 counts 720,809 lines of code in 5,334 of them (1,023,523 lines with comments and blanks).
Where this came from
Extracted by CoreStory V3 (build 4470 with two small engine fixes) using DeepSeek-V4.1-Flash from the public repository at commit 429e56e on 2026-11-17. Capability descriptions are from the same run.
- Repository apache/activemq
- Commit 429e56e94264bd0971ef35c5bee5ba141c3bcb49
- Line counts cloc 2.06
- Rule citations Each rule shown was checked: its quote was compared with the repository source at the cited lines at this commit.
Code excerpts are from the upstream repository and remain under its Apache-2.0 license. CoreStory is not affiliated with or endorsed by the Apache Software Foundation.
Want this for your own codebase?
Talk to us about mapping the business rules in your repositories.