CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-apache-activemq--artemis-commons

Common utilities, API classes, and shared functionality for Apache ActiveMQ Artemis message broker

—

Pending
Overview
Eval results
Files

logging.mddocs/

Logging and Audit

Apache ActiveMQ Artemis Commons provides a comprehensive logging framework with internationalization support and audit capabilities for system events and operations.

Core Logging Interfaces

ActiveMQUtilLogger

Primary logging interface for utility operations in Artemis.

interface ActiveMQUtilLogger {
    // Standard logging methods
    void info(String message);
    void info(String message, Object... params);
    void warn(String message);
    void warn(String message, Object... params);
    void warn(String message, Throwable cause);
    void error(String message);
    void error(String message, Object... params);
    void error(String message, Throwable cause);
    void debug(String message);
    void debug(String message, Object... params);
    void trace(String message);
    void trace(String message, Object... params);
    
    // Conditional logging
    boolean isInfoEnabled();
    boolean isWarnEnabled();
    boolean isErrorEnabled();
    boolean isDebugEnabled();
    boolean isTraceEnabled();
}

ActiveMQUtilBundle

Message bundle interface for internationalized messages.

interface ActiveMQUtilBundle {
    // Internationalized message methods
    String getMessage(String key);
    String getMessage(String key, Object... params);
    
    // Formatted exception messages
    String getExceptionMessage(String key);
    String getExceptionMessage(String key, Object... params);
    
    // Bundle metadata
    String getBundleName();
    Locale getLocale();
}

Audit Logging

AuditLogger

Specialized logging for audit events and security-related operations.

class AuditLogger {
    // Audit event logging
    static void logAuditEvent(String event);
    static void logAuditEvent(String event, Object... params);
    static void logAuditEvent(String event, String details);
    static void logAuditEvent(String event, String details, Object... params);
    
    // Security audit events
    static void logSecurityEvent(String event, String user);
    static void logSecurityEvent(String event, String user, String details);
    
    // Administrative audit events
    static void logAdminEvent(String event, String admin);
    static void logAdminEvent(String event, String admin, String details);
    
    // Configuration and setup
    static void setEnabled(boolean enabled);
    static boolean isEnabled();
    static void setAuditLevel(String level);
}

Bundle Factory

BundleFactory

Factory for creating message bundles with internationalization support.

class BundleFactory {
    // Create message bundles
    static <T> T newBundle(Class<T> bundleInterface);
    static <T> T newBundle(Class<T> bundleInterface, Locale locale);
    static <T> T newBundle(Class<T> bundleInterface, String baseName);
    static <T> T newBundle(Class<T> bundleInterface, String baseName, Locale locale);
    
    // Bundle configuration
    static void setDefaultLocale(Locale locale);
    static Locale getDefaultLocale();
    static void setFallbackLocale(Locale locale);
    static Locale getFallbackLocale();
}

Usage Examples

Basic Logging

import org.apache.activemq.artemis.logs.ActiveMQUtilLogger;

// Get logger instance (typically injected or created by framework)
ActiveMQUtilLogger logger = getLogger();

// Basic logging
logger.info("Server started successfully");
logger.warn("Connection pool nearing capacity: {0}/{1}", currentConnections, maxConnections);
logger.error("Failed to process message", exception);

// Conditional logging for performance
if (logger.isDebugEnabled()) {
    logger.debug("Processing message with ID: {0}, size: {1} bytes", 
                 message.getId(), message.getSize());
}

// Trace logging for detailed debugging
if (logger.isTraceEnabled()) {
    logger.trace("Buffer state: readable={0}, writable={1}, position={2}", 
                 buffer.readableBytes(), buffer.writableBytes(), buffer.readerIndex());
}

Audit Logging

import org.apache.activemq.artemis.logs.AuditLogger;

// Enable audit logging
AuditLogger.setEnabled(true);
AuditLogger.setAuditLevel("INFO");

// Log administrative events
AuditLogger.logAdminEvent("QUEUE_CREATED", "admin", "Queue 'orders' created with max consumers: 10");
AuditLogger.logAdminEvent("QUEUE_DELETED", "admin", "Queue 'temp-queue' deleted");

// Log security events
AuditLogger.logSecurityEvent("USER_LOGIN", "john.doe", "Successful login from 192.168.1.100");
AuditLogger.logSecurityEvent("ACCESS_DENIED", "anonymous", "Attempt to access admin queue without permission");

// Log general audit events
AuditLogger.logAuditEvent("MESSAGE_SENT", "Queue: orders, Size: {0} bytes", messageSize);
AuditLogger.logAuditEvent("CONNECTION_ESTABLISHED", "Client: {0}, Protocol: {1}", clientId, protocol);

// Check if audit logging is enabled before expensive operations
if (AuditLogger.isEnabled()) {
    String details = buildDetailedAuditInfo(operation);
    AuditLogger.logAuditEvent("COMPLEX_OPERATION", details);
}

Internationalized Message Bundles

import org.apache.activemq.artemis.logs.BundleFactory;
import org.apache.activemq.artemis.logs.ActiveMQUtilBundle;

// Create message bundle for default locale
ActiveMQUtilBundle bundle = BundleFactory.newBundle(ActiveMQUtilBundle.class);

// Create bundle for specific locale
ActiveMQUtilBundle spanishBundle = BundleFactory.newBundle(
    ActiveMQUtilBundle.class, 
    new Locale("es", "ES")
);

// Use internationalized messages
String errorMessage = bundle.getMessage("queue.not.found", queueName);
String warningMessage = bundle.getMessage("connection.timeout", timeout, TimeUnit.SECONDS);

// Exception messages
String exceptionMsg = bundle.getExceptionMessage("invalid.configuration", configKey);
throw new ActiveMQException(exceptionMsg);

// Bundle information
String bundleName = bundle.getBundleName();
Locale currentLocale = bundle.getLocale();

Custom Message Bundle Interface

// Define custom message bundle interface
public interface MyComponentBundle {
    @Message(id = 1001, value = "Queue {0} created successfully")
    String queueCreated(String queueName);
    
    @Message(id = 1002, value = "Failed to connect to broker at {0}:{1}")
    String connectionFailed(String host, int port);
    
    @Message(id = 1003, value = "Message processing completed in {0}ms")  
    String processingCompleted(long durationMs);
    
    @Message(id = 1004, value = "Invalid routing type: {0}. Expected: {1}")
    ActiveMQException invalidRoutingType(String actual, String expected);
}

// Use custom bundle
MyComponentBundle messages = BundleFactory.newBundle(MyComponentBundle.class);

// Log with internationalized messages
logger.info(messages.queueCreated("orders"));
logger.error(messages.connectionFailed("localhost", 61616));
logger.debug(messages.processingCompleted(processingTime));

// Throw internationalized exceptions
throw messages.invalidRoutingType("UNKNOWN", "ANYCAST or MULTICAST");

Structured Logging with Context

public class QueueManager {
    private final ActiveMQUtilLogger logger;
    private final String componentName;
    
    public QueueManager(String componentName) {
        this.componentName = componentName;
        this.logger = getLogger();
    }
    
    public void createQueue(QueueConfiguration config) {
        String queueName = config.getName().toString();
        
        // Log operation start
        logger.info("[{0}] Creating queue: {1}", componentName, queueName);
        
        try {
            // Perform queue creation
            doCreateQueue(config);
            
            // Log success with details
            logger.info("[{0}] Queue created successfully: name={1}, durable={2}, maxConsumers={3}", 
                       componentName, queueName, config.getDurable(), config.getMaxConsumers());
            
            // Audit the administrative action
            AuditLogger.logAdminEvent("QUEUE_CREATED", getCurrentUser(), 
                                    String.format("Queue: %s, Component: %s", queueName, componentName));
            
        } catch (Exception e) {
            // Log error with context
            logger.error("[{0}] Failed to create queue: {1}", componentName, queueName, e);
            
            // Audit the failure
            AuditLogger.logAuditEvent("QUEUE_CREATION_FAILED", 
                                    "Queue: {0}, Component: {1}, Error: {2}", 
                                    queueName, componentName, e.getMessage());
            throw e;
        }
    }
}

Performance-Optimized Logging

public class HighThroughputProcessor {
    private final ActiveMQUtilLogger logger;
    
    public void processMessage(Message message) {
        // Use conditional logging to avoid expensive string operations
        if (logger.isDebugEnabled()) {
            logger.debug("Processing message: id={0}, type={1}, size={2}", 
                        message.getId(), message.getType(), message.getSize());
        }
        
        try {
            // Process message
            Object result = doProcessMessage(message);
            
            // Log only critical information at INFO level
            if (result != null) {
                logger.info("Message processed successfully: {0}", message.getId());
            }
            
            // Detailed trace logging
            if (logger.isTraceEnabled()) {
                logger.trace("Processing result: {0}, duration={1}ms, memory={2}MB", 
                           result.toString(), getDuration(), getMemoryUsage());
            }
            
        } catch (Exception e) {
            // Always log errors
            logger.error("Message processing failed: {0}", message.getId(), e);
            
            // Audit critical failures
            if (isCriticalError(e)) {
                AuditLogger.logAuditEvent("CRITICAL_PROCESSING_ERROR", 
                                        "Message: {0}, Error: {1}", 
                                        message.getId(), e.getClass().getSimpleName());
            }
        }
    }
}

Configuration-Based Logging Setup

public class LoggingConfiguration {
    
    public void configureLogging() {
        // Set up bundle factory defaults
        BundleFactory.setDefaultLocale(Locale.getDefault());
        BundleFactory.setFallbackLocale(Locale.ENGLISH);
        
        // Configure audit logging based on system properties
        boolean auditEnabled = Boolean.parseBoolean(
            System.getProperty("artemis.audit.enabled", "false"));
        AuditLogger.setEnabled(auditEnabled);
        
        if (auditEnabled) {
            String auditLevel = System.getProperty("artemis.audit.level", "INFO");
            AuditLogger.setAuditLevel(auditLevel);
        }
        
        // Log configuration
        ActiveMQUtilLogger logger = getLogger();
        logger.info("Logging configured: audit={0}, locale={1}", 
                   auditEnabled, BundleFactory.getDefaultLocale());
    }
}

Integration Patterns

Exception Logging Pattern

public class ServiceComponent {
    private final ActiveMQUtilLogger logger;
    private final MyComponentBundle messages;
    
    public ServiceComponent() {
        this.logger = getLogger();
        this.messages = BundleFactory.newBundle(MyComponentBundle.class);
    }
    
    public void performOperation() throws ActiveMQException {
        logger.info("Starting operation");
        
        try {
            doOperation();
            logger.info("Operation completed successfully");
            
        } catch (ActiveMQException e) {
            // Log and re-throw ActiveMQ exceptions
            logger.error(messages.operationFailed(), e);
            throw e;
            
        } catch (Exception e) {
            // Wrap and log other exceptions
            String errorMsg = messages.unexpectedError(e.getMessage());
            logger.error(errorMsg, e);
            throw new ActiveMQInternalErrorException(errorMsg, e);
        }
    }
}

Request/Response Logging Pattern

public class MessageHandler {
    private final ActiveMQUtilLogger logger;
    
    public void handleRequest(String requestId, Object request) {
        // Log request start
        logger.info("Processing request: {0}", requestId);
        
        if (logger.isDebugEnabled()) {
            logger.debug("Request details: {0}, type={1}", 
                        requestId, request.getClass().getSimpleName());
        }
        
        long startTime = System.currentTimeMillis();
        
        try {
            Object response = processRequest(request);
            long duration = System.currentTimeMillis() - startTime;
            
            // Log successful completion
            logger.info("Request completed: {0}, duration={1}ms", requestId, duration);
            
            // Trace response details
            if (logger.isTraceEnabled()) {
                logger.trace("Response for {0}: {1}", requestId, response);
            }
            
        } catch (Exception e) {
            long duration = System.currentTimeMillis() - startTime;
            logger.error("Request failed: {0}, duration={1}ms", requestId, duration, e);
            
            // Audit significant failures
            AuditLogger.logAuditEvent("REQUEST_PROCESSING_FAILED", 
                                    "RequestId: {0}, Duration: {1}ms, Error: {2}", 
                                    requestId, duration, e.getMessage());
        }
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-activemq--artemis-commons

docs

actors.md

collections.md

core-api.md

exceptions.md

index.md

json-api.md

logging.md

utilities.md

tile.json