Author(s): Bruce Snyder, Dejan Bosanac, and Rob Davies
Published: November 2010
A comfortable way to learn the most important topics about ActiveMQ, letting you know how work with the messaging world in your applications, including not overloading theory and a lot of valuables images to get an excellent understanding.
You can learn ActiveMQ in many aspects like configuration (Connection, Persistence and Securing), building Messages Applications, Tuning and Administration
Therefore I recommend this book, below my long review to let you have a complete idea about what expect if you buy this book, recall that this review is based in a MEAP status
This Book is available here
Part I: An Introduction to Messaging and ActiveMQ
Chapter 01: Introduction to Apache ActiveMQ
The chapter starts quickly with the section What is ActiveMQ? based in a concrete theory and covering the follow subsections ActiveMQ Features explaining about JMS Compliance, Connectivity, Pluggable Persistence and Security and others, well covering for these sub topics. The follow subsection is Why Use ActiveMQ? based with a concrete theory, offering furthermore an image about Two tightly-coupled RPC applications with its respective explanation, even following with other image called Two loosely-coupled JMS applications again with its respective explanation. The follow subsection is When and Where to Use ActiveMQ where practically two pages with interesting explanation you have available
The follow section is Getting Started With ActiveMQ covering the follow sub sections:
- Download and Install the Java SE
- Download ActiveMQ
- Examining the ActiveMQ Directory (well explained)
- Starting Up ActiveMQ (including a table discussion called Uniquely Naming An ActiveMQ Broker, almost two pages about this)
- Verifying Your ActiveMQ Setup With the Examples (well explained and including many output results)
Chapter 02: Understanding Message-Oriented Middleware and JMS
The chapter start with the section Introduction to Enterprise Messaging including a concrete theory followed by two images, the first called Terminals connecting to a mainframe and the second Terminals and applications connecting to a mainframe well explanation for this section.
The follow section available is What is Message Oriented Middleware?, therefore we talk about MOM, concrete theory including an image about Introducing message-oriented middleware, well explanation used.
Then the follow section is What is the Java Message Service?, then we talk now about JMS, well covered and again including an image about JMS allows a single client to easily connect to many JMS providers, a page about a list with its respective brief and concrete explanation for each element is available about concepts and artifacts from the world of messaging. Furthermore in this section we have our first sub section called Messaging Clients covering the subtopic JMS Clients explaining the follow inner-subtopics about:
- JMS Producer (based in the code for the interface MessageProducer)
- JMS Consumer (based in the code for the interface MessageConsumer)
The follow subtopic Non-JMS Clients, based in a short and concrete theory
The follow sub section is The JMS Provider really a brief explanation used, therefore we follow with the sub section Anatomy of a JMS Message, which includes an important image about A graphical representation of a JMS message, then we follow with the subtopic JMS Message Headers covering about JMSDestination,JMSDeliveryMode,JMSExpiration and others, long covering, practically four pages, the follow subtopic is JMS Message Properties showing the interface Message including a brief explanation, furthermore we have three inner-subtopics for this subtopic
- Custom Properties
- JMS-Defined Properties (interesting covering for JMSX properties like JMSXAppID, JMSXConsumerTXID, JMSXDeliveryCount and more)
- Provider-Specific Properties
Following with the sub section Message Selectors with a covering for SQL92, including a table JMS Selector Syntax and showing many snippet code
- A JMS message with custom properties
- Filter messages using the SYMBOL header
- Filter messages using both the SYMBOL and PRICE headers
- Filter messages using the SYMBOL header, the PRICE header
Practically three pages for these codes with its respective explanation. We have available the subtopic called Message Body where the JMS six Java types for the message body (payload) are listed an explained.
The follow sub section is JMS Domains starting quickly with the subtopic The Point-to-Point Domain including an important image about Point-to-point messaging uses a one-to-one messaging paradigm with its respective explanation, the follow subtopic is The Publish/Subscribe Domain again with an image called Publish/Subscribe uses a one-to-many messaging paradigm with its respective explanation, here we have an interesting cover for a inner-subtopic called Distinguishing Message Durability From Message Persistence really well explained including a table discussion called Request/Reply Messaging in JMS Applications which it include an image called The steps involved in basic request/reply messaging
Other sub section is Administered Objects based with concrete theory about the subtopics called ConnectionFactory and Destination.
Then we go to the sub section Using the JMS APIs to Create JMS Applications based mostly in a list about many parts in handling different aspects of working with JMS and showing us an important code with a detailed explanation (the classic Manning approach in use black circles with number) for Using the JMS API to send a message and Using the JMS API to receive a message, practically three pages in these, really well explained, even more a table discussion is included A Note on Multithreading in JMS Applications
The last sub section ant to end the chapter is Message-Driven Beans based in an explanation for a code called A simple message-driven bean example with its respective explanation, a table discussion Not Every EJB Container Requires a Full Java EE Container – Try OpenEJB is included
Chapter 03: The ActiveMQ In Action Examples
We start with the section Understanding the Example Use Cases it is related about the point-to-point messaging domain , then we forward to the sub section Prerequisites covering with a concrete approach the follow sub topic in almost four pages
- Download and Install Apache Ant
- Download and Install Apache Maven
We turn with the follow sub section ActiveMQ In Action Examples covering the follow subtopics:
- Downloading the Examples
- Compiling the Examples
- Use Case One: The Stock Portfolio Example (based in publish-subscribe messaging and including an image about The stock portfolio example for a better explanation)
- Running the Stock Portfolio Example (based in three steps Start up ActiveMQ, Run the Consumer class, Run the Publisher class, showing us the console output, practically nine pages for these topics, even including a table discussion called Why Are All the Artifacts Being Downloaded From the localhost in the Output Shown Above?, here we talk about Nexus (sonatype))
- Use Case Two: The Job Queue Example (based in point-to-point messaging and including an image about The job queue example for a better explanation)
- Running the Job Queues Example (based in three steps Start up ActiveMQ, Run the Producer class, Run the Consumer class, showing us the console output, practically four pages for these topics)
Part II: How to Configure ActiveMQ
Chapter 04: Connecting to ActiveMQ
Our first section is Understanding Connector URIs covering about URI formats (http,tcp) and path and query elements, including an image to understand the URI structure schema, path, query with a concrete overview about that, we have even other image about composite uri again with its respective overview
The follow section is Configuring Transport Connectors covering about conf/activemq.xml and including a snippet code about transportConnectors tag, doing its respective overview, following with an output for these connectors in start up, following again with a snippet code about ActiveMQConnectionFactory. We follow with the sub section Using Transport Connectors including a Java code about Modifying stock portfolio publisher to support various connector URIs with its respective explanation, same appreciation for the code Modifying stock portfolio consumer to support various connector URIs practically three pages in cover these. The follow sub topic is Using Network Protocols covering the follow sub topics:
- Transmission Control Protocol (TCP) (About transportConnectors,transportConnector tags,uri=”tcp:…”, and listing and explaining each item about benefits of the TCP transport connector)
- New I/O API Protocol (NIO) (again with transportConnectors,transportConnector tags, uri=”nio:….”, including an interesting image about Producer sends messages using nio transport, consumer receives them using tcp transport following with an output working with maven execution)
- User Datagram Protocol (UDP) (including a table discussion called Comparing the TCP and UDP Transports, again with transportConnectors,transportConnector tags, uri=”udp:…” )
- Secure Sockets Layer Protocol (SSL) (The same tags seen before, uri=”ssl:…”,system properties like keyStore,keyStorePassword,trustStore are listed and explained with brief theory, many outputs executing these command are available with and without maven, four pages well covered for these)
- Hypertext Transfer Protocol (HTTP/HTTPS) (Again same tags seen before, uri=”http:…” )
The follow subsection is Using the Virtual Machine Protocol covering the subtopic VM Protocol (Based in many URI’s formats using vm, including an image about Application exchanges messages with embedded broker using vm transport)
The follow section is Configuring Network Connectors starting with good theory and following with a very important image called An example of complex network of brokers topology with a explanation about a snippet code networkConnectors tag, then the sub section Defining Static Networks is available, covering the sub topics
- Static Protocol (including an image about Two application exchange messages using two brokers in a static network and many xml configurations, even more we have an inner-subtopic Example Use of the Static Protocol based in a concrete theory)
- Failover Protocol (well theory and covered, including an inner-subtopic called Example Use of the Failover Protocol)
Other sub section available is Defining Dynamic networks covering the sub topics:
Multicast Protocol (based in some XML configurations and including a table discussion called Preventing Automatic Broker Discovery
practically in two pages and even including an inner-subtopic Example Use of the Multicast Protocol)
- Discovery Protocol
- Peer Protocol (including an image Two applications communicating using embedded brokers over peer protocol and its inner-subtopic Example Use of the Peer Protocol)
- Fanout Protocol (including an image about Producer sends messages to multiple brokers using fanout protocol )
Chapter 05: Message Persistence
Here we start reading about the JMS specification which supports two types of message delivery, persistent and non-persistent.
Then we go to the section How Are Messages Stored by ActiveMQ?, we have an introduction about FIFO, followed with two images for a better understanding FIFO message storage for queues and Messages Stored for Topics.
The follow section is Available Message Stores in ActiveMQ, covering the follow subsections The AMQ Message Store about persistenceAdapter tag in the activemq.xml, with a Java code working with PersistenceAdapterFactory, here we have even a sub topic called The AMQ Message Store Internals including an image about The AMQ message Store and explaining with a list about The Journal, The Cache, The Reference Store, other sub topic is The AMQ Message Store Directory Structure including an image about The AMQ message store directory structure and explaining again with a list about The data directory, The state directory, A lock file and many others. Other sub topic is Configuring the AMQ Message Store based in a table in almost two pages about The key properties for the AMQ store followed by the last sub topic about When to Use the AMQ Message Store including a brief theory.
The other sub section is The KahaDB Message Store, interesting theory and including too an interesting image about The KahaDB message store. Then now we follow with the sub topic Configuring the KahaDB Message Store based in a table in almost one page about options for configuration, other sub topic is When to use the KahaDB Store based in a brief theory.
The follow sub section is The JDBC Message Store starting quickly with the sub topic Databases supported by the JDBC Message Store based in a list for the follow databases (Apache Derby,MySQL,PostgreSQL,Oracle,SQLServer,Sybase,Informix,MaxDB) followed with a table discussion Using Apache Derby With ActiveMQ. Then we turn to the follow sub topic The JDBC Message Store Schema including two tables about ACTIVEMQ_MSGS and ACTIVEMQ_ACKS showing its attributes, other sub topic are
- Configuring the JDBC Message Store (based in many XML configurations)
- When to use the JDBC Message Store (based in a concrete theory)
- Using the JDBC Message Store With the ActiveMQ Journal (based in a XML configuration)
and the last sub topic and shortest is When to Use the JDBC Message Store With the Journal, brief theory.
Other sub section is The Memory Message Store, starting quickly with the sub topic Configuring the Memory Store based in a XML configuration and the snippet code about the method createEmbeddedBroker, the last subtopic is When to Use the Memory Message Store based in a concrete theory.
The last section of the chapter is Caching Messages in the Broker for Consumers starting with the sub section How Message Caching for Consumers Works based in a snippet code
for the method createRetroactiveConsumer, other sub section The ActiveMQ Subscription Recovery Policies covering the follow sub topics
- The ActiveMQ Fixed Size Subscription Recovery Policy
- The ActiveMQ Fixed Count Subscription Recovery Policy
- The ActiveMQ Query Based Subscription Recovery Policy
- The ActiveMQ Timed Subscription Recovery Policy
- The ActiveMQ Last Image Subscription Recovery Policy
- The ActiveMQ No Subscription Recovery Policy
Almost these sub topics are covered with concrete tables about the description of some properties
The last sub section is Configuring The Subscription Recovery Policy based practically in one page about XML configuration.
Chapter 06: Securing ActiveMQ
He we start quickly with the section Introducing Basic Security Concepts covering about an introduction for two important concepts Authentication and Authorization.
Therefore we go to the subsection Authentication covering two plugins , the first one covered under the sub topic Configuring the Simple Authentication Plugin showing a XML configuration with its respective explanation, something interesting is that the author shown us an expected exception and proceed to fix it. The follow sub topic is Configuring the JAAS Plugin,based with theory and some content about configuration for users.properties and groups.properties.
The follow section is Authorization starting with the sub topic Operation Level Authorization covering three types of user level operations with JMS destinations like Read, Write, Admin, followed with a XML configuration with its respective configuration. Then we turn to the sub topic Message Level Authorization that consist in explain a Java class that implements the interface org.apache.activemq.security.MessageAuthorizationPolicy.
We follow now with the section Broker Level Operations with good theory and covering with a concrete explanation about Implement a JAAS login module and Implement a custom plugin for handling security. Then we turn to the sub section Building A Custom Security Plugin based in a Java class IPAuthenticationBroker code that implements the interface BrokerFilter, of course with its respective explanation, followed with a XML configuration with is respective explanation.
Part III: Using ActiveMQ to Build Messaging Applications
Chapter 07: Creating Java Applications With ActiveMQ
Here we start quickly with the section Integrating Broker, and going to the sub section Embedding The Broker, where here start quickly with the sub topic Broker Service covering for org.apache.activemq.broker.BrokerService class, where we have a XML configuration and a Main class using such class (BrokerService), with its respective explanation and including its output. The follow subtopic is Broker Factory where now we use the org.apache.activemq.broker.BrokerFactory class in action, again a Main class is shown with its respective output.
Now we go to the sub section Integrating With Spring Framework starting quickly with the sub topic Integrating The Broker where we have a Java class called SpringBroker using the org.apache.xbean.spring.context.FileSystemXmlApplicationContext class, again output is shown. Here we have some inner subtopics like:
- Spring 1.0 (where we have available a bean configuration for BrokerFactoryBean)
- Spring 2.0 (where we have in almost one page a XML configuration using amq schema)
- XBean (based in a brief explanation)
The follow sub topic is Integrating Clients starting quickly in cover the inner sub topics:
- Defining Connections (including beans configuration for ActiveMQConnectionFactory and PooledConnectionFactory classes )
- Defining destinations (again showing bean configuration for ActiveMQTopic class )
- Defining consumers (working with the class DefaultMessageListenerContainer)
- Defining producers (we have a Java class implementing the interface MessageCreator and other class called SpringPublisher, almost three pages in Java code, furthermore of beans configuration for our classes and JmsTemplate class)
- Putting it all together (a Main class and with a maven command, we can read its respective output)
Chapter 08: Embedding ActiveMQ In Other Java Containers
Since this book is in status MEAP, this chapter only consist by the moment about the section Introduction, but what you should expect is about embed ActiveMQ into another application
- Understand how to embed ActiveMQ in a plain old Java application
- Walk through examples of embedding ActiveMQ in other application
containers such as:
- Apache Tomcat
- Apache Geronimo
Chapter 09: Connecting to ActiveMQ With Other Languages
We work here with STOMP (Streaming Text Orientated Messaging Protocol) protocol, and with other languages like Ruby, Python, PHP and Perl, C++ and .NET
Therefore we start with the section Preparing Examples based in a Java code about Modified publisher, practically one page followed with a maven command execution and its respective output.
The follow section is Communicating with the STOMP protocol doing mention to OpenWire and STOMP, some output about STOMP session (with telnet) and STOMP transport are available, followed with an image about Stomp Example. Therefore we turn to the sub section Writing Ruby client, including of course a Ruby code, with its respective explanation and output. We follow with the sub section Creating Python client, where two script code are included, a helper and consumer code, explanation available and its respective output. Here even we have a sub topic called Messaging with pyactivemq where practically in four pages we have available two script code and its respective output. The follow sub section is Building PHP client where same approach for the previous sub sections was used. Other sub section is Implementing Perl client, same approach used. Ok, something interesting is about the follow sub section called Understanding Stomp transactions where snippet code and a PHP code is available about Transaction send/ack approach.
Other sub section is Working with Durable Topic Subscribers where we have available a PHP code about Durable Topic Subscriber example in almost two pages with its respective output.
We have a section called Learning NMS (.Net Message Service) API based in a C# code with a mono command execution (after to use gmcs command). We have other section called Introducing CMS (C++ Messaging Service) API where after of a concrete theory we have a code about C++ Message Listener and other c++ code, after these, the respective output is available.
Part IV: Advanced Features in ActiveMQ
Chapter 10: Broker Topologies
Starting quickly with the section Broker High Availability and covering the subsection Shared Nothing Master/Slave with a concrete theory followed by an image called ‘Shared Nothing’ master/slave and more theory yet. Here even we have a sub topic Configuring ‘Shared Nothing’ master/slave including a snippet code for a desired configuration followed for some tables about slave Broker properties and master Broker properties with a concrete explanation for each item. We have other sub topic yet, called When to use ‘Shared Nothing’ master/slave based in a concrete theory.
We follow with the sub section Shared Database Master/Slave including quickly an image about Shared Database master/slave and respective theory. We have yet a sub topic about When to use shared database master/slave with a concrete theory. Other sub section is Shared File system Master/Slave including quickly an image about Shared File System master/slave followed with concrete theory and we have yet a sub topic called When to use shared file system master/slave which is based in a concrete theory.
We turn to the section Networks of Brokers where after to read a concrete theory we have the sub section Store and Forward which shown quickly an image about Network Connection and including its respective theory, even we have other image called Store and Back office followed by a snippet code about Configuring a Store Network Broker and including an important advice about configuration networks, persistence and transports based in an important order list to take care; therefore a snippet code about Correct Configuration Order is shown, after this we have in one page an important image called Combining High Availability and networks.
Now we turn to the sub section Network Discovery where we have two main types of network discovery that come out of the box with ActiveMQ (dynamic and static), then a snippet code about Multicast discovery for Networks and Network configuration for high availability are shown, including important theory. Tables about static configuration properties are available, explaining each item, ending this sub section with a snippet code about Setting options with static discovery for networks.
Other sub section available is Network Configuration where after to a well theory we follow with the sub topics (almost all these covered with concrete theory)
- Network Property: dynamicOnly
- Network Property: conduitSubscriptions
- Network Property: excludedDestinations (include a snippet code about Setting options for excluded destinations)
- Network Property: dynamicallyIncludedDestinations
- Network Property: staticallyIncludedDestinations (include a snippet code about Setting options for included destinations)
- Network Property: decreaseNetworkConsumerPriority
- Network Property: networkTTL
- Network Property: name (including an image about ‘Shared Nothing’ master/slave and snippet code about Setting options for included destinations)
The follow and last section is Scaling Applications starting quickly with the sub section Vertical Scaling including a snippet code about Setting nio as the default ActiveMQ transport connector among other snippet code of configurations. Other sub section is Horizontal Scaling based in some snippet code of configurations and concrete theory. Other sub section Traffic Partitioning including an image about Combining High Availability and networks.
Chapter 11: Advanced ActiveMQ Broker Features
We have after the section Introduction with a brief theory the section Wildcards and Composite Destinations covering quickly the sub section Subscribing to Wildcard Destinations based in a well theory about special characters and a snippet code about Subscribing to wildcards. We follow with the sub section Sending a Message to Multiple Destinations again covered with a well theory and a snippet code about Sending to Composite Destinations.
The follow section is Advisory Messages doing mention about originBrokerId, originBrokerName, originBrokerURL followed with a snippet code about Subscribing for Connection Advisories and Subscribing for Consumer Advisories with its respective explanation, ending with a snippet code about Enabling Slow Consumer Advisories.
We follow with the section Virtual Topics including an image under the same name of this section, followed with a snippet code about Setting up VirtualTopics. We turn now to the section Retroactive Consumers including a snippet code Setting A Retroactive Consumer and snippet configuration Configuring a Subscription Recovery Policy.
The last section Message Redelivery and Dead-letter Queues which includes a snippet code about Configuring a Subscription Recovery Policy and Configuring a Dead Letter Strategy.
Chapter 12: Advanced Client Options
We start quickly with the section Exclusive Consumer where after of a well theory an image about Exclusive Consumer is available doing emphasis about Consumer stops or looses connection, a snippet code about Creating an Exclusive Consumer is available too. We follow with the sub section Exclusive Consumer Example, where after of a concrete theory we have an image about An Exclusive Producer scenario followed by a method code about Creating an Exclusive Consumer and MessageListener for Exclusive Producer.
We turn to the section Message Groups covering about Message header JMSXGroupID followed by an image about Message Groups and snippet code about Create a Message Group and Close a Message Group, other two snippet code are included too, with its respective explanation.
The follow section is ActiveMQ Streams where we have an important image about Transferring a File using Streams and a snippet code about Sending data over an ActiveMQ Stream and Receiving data from an ActiveMQ Stream well amount the code.
The last section is Blob Messages including snippet code about Sending a BlobMessage and Processing a Blob message.
Chapter 13: Tuning ActiveMQ For Performance
The first section is General Techniques covering the sub sections:
- Persistent vs Non-Persistent Messages (including an image about Persistent Message delivery and snippet code about Setting the delivery mode )
- Transactions (including almost one page for a code about Transacted and non-transacted example)
- Embedding Brokers (including an image about Co-locate with a Broker and snippet code Creating a Queue Service and Connecting a QueueRequestor, well code )
- Tuning the OpenWire protocol (almost two pages for a table called OpenWire Tuning Parameters and snippet code for Setting OpenWire options)
- Tuning the TCP Transport (covering about two parameters that directly affect performance socketBufferSize tcpNoDelay and snippet code about Setting the TCP no delay option)
The follow section is Optimizing Message Producers covering the follow sub sections:
- Asynchronous send (including a snippet code Setting the delivery mode and well theory too)
- Producer Flow Control (including an image about Producer Flow Control enabled and snippet code about Setting the producer window size and How to disable flow control and even including other image Producer Flow control disabled, well explained )
The follow section is Optimizing Message Consumers covering the sub sections:
- Prefetch Limit (including an interesting image about Connection internals and listing default prefetch sizes for different consumers, furthermore of snippet code about Setting the prefetch policy and Setting prefetch policy on a Destination)
- Delivery and Acknowledgement of messages (well theory and including a snippet code about Setting optimize acknowledge and a table for Different acknowledgment modes)
- Asynchronous dispatch (including an snippet code about Setting always use asynchronous dispatch and an important image called Optimized Connection internals)
The last section is Putting it all Together including an image about Data feed application and snippet code for Creating the embedded broker, Creating the producer and Creating the Consumer, well amount of code.
Chapter 14: Administering and Monitoring ActiveMQ
After of almost one page about introduction we start with the section APIs starting quickly the sub section JMX and this covering quickly the sub topic Local vs. Remote JMX Access covering about ActiveMQ startup script for Linux/Unix and windows, a good amount of images are available here like Accessing ActiveMQ locally from Jconsole and The main jconsole screen with the ActiveMQ domain included among others, the follow sub topic is Exposing the JMX MBeans For ActiveMQ including a snippet code about ActiveMQ JMX configuration and explanation, other sub topic is Using the JMX APIs With ActiveMQ including a snippet code about ActiveMQ broker statistics with its respective explanation and output, well covered. Even more, other sub topic is Advanced JMX Configuration based in ActiveMQ startup script for Linux/Unix and windows.
More yet, we have the inner-subtopic called Enabling Remote JMX Access based in snippet code about ActiveMQ startup script for Linux/Unix with the com.sun.management.jmxremote.port and an image called Accessing the JMX Agent remotely on port 1234. The follow inner-subtopic is Restricting JMX Access to a Specific Host based in concrete theory and snippet code.Other inner-subtopic is Configuring JMX Password Authentication showing and explaining jmxremote.access file, same appreciation for jmxremote.password.template file, followed by many snippet code configurations and the execution for the script ./bin/activemq with its respective output and two images about remotely connect to the JMX agent with wrong and correct information to access it.
The follow sub section is Advisory Messages based in a snippet code about Configuring advisory support with its respective explanation, including other snippet code for Advisory example (practically one page for this code), followed with its respective explanation, even other snippet code is available Consumer advisory listener with its respective explanation, to end here, other snippet code is available No consumer advisory listener including the output, almost in two pages.
The follow section is Tools starting quickly with the sub section Command-Line Tools, covering the follow sub topics:
- Starting and Stopping the Broker (based in many command executions and furthermore in more of one page the ActiveMQ startup script (bin/activemq) is shown )
- Listing Avaiable Brokers (including the output of the execution for activemq-admin list)
- Querying the Broker (including the output of the execution for activemq-admin query, practically one page for this)
- Browsing Destinations (including the output of the execution for activemq-admin browse, almost one page for this)
The follow sub section is Command Agent including the a snippet code about Command Agent configuration and doing mention about XMPP (the Extensible Messaging and Presence Protocol) some images are available too like XMPP subscribe to agent topic, Command Agent help and Command Agent query
The follow sub section is JConsole based in many images like JConsole connect, JConsole Queue View, JConsole Queue Operations. Other sub section is too Web Console doing mention about http://localhost:8161/admin/ and showing two images about Web console.
The last section is Logging doing mention to conf/log4j.properties and data/activemq.log, image about Reload Log4J properties is included too, we have the sub section Client Logging where the author shown us a snippet code about Client logging a good amount of lines about output are shown, the follow sub section is Logging Interceptor doing mention to conf/activemq.xml.