activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From clebertsuco...@apache.org
Subject [5/9] activemq-6 git commit: update user manual to use the phrase 'Apache ActiveMQ'
Date Tue, 03 Mar 2015 17:18:55 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/interoperability.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/interoperability.md b/docs/user-manual/en/interoperability.md
index e4d0b58..1b02245 100644
--- a/docs/user-manual/en/interoperability.md
+++ b/docs/user-manual/en/interoperability.md
@@ -3,7 +3,7 @@
 ## Stomp
 
 [Stomp](http://stomp.github.com/) is a text-orientated wire protocol
-that allows Stomp clients to communicate with Stomp Brokers. ActiveMQ
+that allows Stomp clients to communicate with Stomp Brokers. Apache ActiveMQ
 now supports Stomp 1.0, 1.1 and 1.2.
 
 Stomp clients are available for several languages and platforms making
@@ -11,16 +11,16 @@ it a good choice for interoperability.
 
 ## Native Stomp support
 
-ActiveMQ provides native support for Stomp. To be able to send and
+Apache ActiveMQ provides native support for Stomp. To be able to send and
 receive Stomp messages, you must configure a `NettyAcceptor` with a
 `protocols` parameter set to have `stomp`:
 
     <acceptor name="stomp-acceptor">tcp://localhost:61613?protocols=STOMP</acceptor>
 
-With this configuration, ActiveMQ will accept Stomp connections on the
+With this configuration, Apache ActiveMQ will accept Stomp connections on the
 port `61613` (which is the default port of the Stomp brokers).
 
-See the `stomp` example which shows how to configure a ActiveMQ server
+See the `stomp` example which shows how to configure an Apache ActiveMQ server
 with Stomp.
 
 ### Limitations
@@ -33,30 +33,30 @@ set).
 
 #### Virtual Hosting
 
-ActiveMQ currently doesn't support virtual hosting, which means the
+Apache ActiveMQ currently doesn't support virtual hosting, which means the
 'host' header in CONNECT fram will be ignored.
 
 #### Heart-beating
 
-ActiveMQ specifies a minimum value for both client and server heart-beat
+Apache ActiveMQ specifies a minimum value for both client and server heart-beat
 intervals. The minimum interval for both client and server heartbeats is
 500 milliseconds. That means if a client sends a CONNECT frame with
 heartbeat values lower than 500, the server will defaults the value to
 500 milliseconds regardless the values of the 'heart-beat' header in the
 frame.
 
-### Mapping Stomp destinations to ActiveMQ addresses and queues
+### Mapping Stomp destinations to Apache ActiveMQ addresses and queues
 
 Stomp clients deals with *destinations* when sending messages and
 subscribing. Destination names are simply strings which are mapped to
 some form of destination on the server - how the server translates these
 is left to the server implementation.
 
-In ActiveMQ, these destinations are mapped to *addresses* and *queues*.
+In Apache ActiveMQ, these destinations are mapped to *addresses* and *queues*.
 When a Stomp client sends a message (using a `SEND` frame), the
 specified destination is mapped to an address. When a Stomp client
 subscribes (or unsubscribes) for a destination (using a `SUBSCRIBE` or
-`UNSUBSCRIBE` frame), the destination is mapped to a ActiveMQ queue.
+`UNSUBSCRIBE` frame), the destination is mapped to an Apache ActiveMQ queue.
 
 ### STOMP and connection-ttl
 
@@ -96,7 +96,7 @@ seconds.
 #### Using JMS destinations
 
 As explained in [Mapping JMS Concepts to the Core API](jms-core-mapping.md),
-JMS destinations are also mapped to ActiveMQ
+JMS destinations are also mapped to Apache ActiveMQ
 addresses and queues. If you want to use Stomp to send messages to JMS
 destinations, the Stomp destinations must follow the same convention:
 
@@ -123,10 +123,10 @@ destinations, the Stomp destinations must follow the same convention:
 
         ^@
 
-#### Sending and consuming Stomp message from JMS or ActiveMQ Core API
+#### Sending and consuming Stomp message from JMS or Apache ActiveMQ Core API
 
 Stomp is mainly a text-orientated protocol. To make it simpler to
-interoperate with JMS and ActiveMQ Core API, our Stomp implementation
+interoperate with JMS and Apache ActiveMQ Core API, our Stomp implementation
 checks for presence of the `content-length` header to decide how to map
 a Stomp message to a JMS Message or a Core message.
 
@@ -147,7 +147,7 @@ header to determine the type of the message body (String or bytes).
 When receiving Stomp messages via a JMS consumer or a QueueBrowser, the
 messages have no properties like JMSMessageID by default. However this
 may bring some inconvenience to clients who wants an ID for their
-purpose. ActiveMQ Stomp provides a parameter to enable message ID on
+purpose. Apache ActiveMQ Stomp provides a parameter to enable message ID on
 each incoming Stomp message. If you want each Stomp message to have a
 unique ID, just set the `stompEnableMessageId` to true. For example:
 
@@ -167,15 +167,15 @@ default is `false`.
 #### Handling of Large Messages with Stomp
 
 Stomp clients may send very large bodys of frames which can exceed the
-size of ActiveMQ server's internal buffer, causing unexpected errors. To
-prevent this situation from happening, ActiveMQ provides a stomp
+size of Apache ActiveMQ server's internal buffer, causing unexpected errors. To
+prevent this situation from happening, Apache ActiveMQ provides a stomp
 configuration attribute `stompMinLargeMessageSize`. This attribute
 can be configured inside a stomp acceptor, as a parameter. For example:
 
        <acceptor name="stomp-acceptor">tcp://localhost:61613?protocols=STOMP;stompMinLargeMessageSize=10240</acceptor>
 
 The type of this attribute is integer. When this attributed is
-configured, ActiveMQ server will check the size of the body of each
+configured, Apache ActiveMQ server will check the size of the body of each
 Stomp frame arrived from connections established with this acceptor. If
 the size of the body is equal or greater than the value of
 `stompMinLargeMessageSize`, the message will be persisted as a large
@@ -190,16 +190,16 @@ sending it to stomp clients. The default value of
 
 ### Stomp Over Web Sockets
 
-ActiveMQ also support Stomp over [Web
+Apache ActiveMQ also support Stomp over [Web
 Sockets](http://dev.w3.org/html5/websockets/). Modern web browser which
-support Web Sockets can send and receive Stomp messages from ActiveMQ.
+support Web Sockets can send and receive Stomp messages from Apache ActiveMQ.
 
 To enable Stomp over Web Sockets, you must configure a `NettyAcceptor`
 with a `protocol` parameter set to `stomp_ws`:
 
     <acceptor name="stomp-ws-acceptor">tcp://localhost:61614?protocols=STOMP_WS</acceptor>
 
-With this configuration, ActiveMQ will accept Stomp connections over Web
+With this configuration, Apache ActiveMQ will accept Stomp connections over Web
 Sockets on the port `61614` with the URL path `/stomp`. Web browser can
 then connect to `ws://<server>:61614/stomp` using a Web Socket to send
 and receive Stomp messages.
@@ -209,7 +209,7 @@ available from [GitHub](http://github.com/jmesnil/stomp-websocket)
 (please see its [documentation](http://jmesnil.net/stomp-websocket/doc/)
 for a complete description).
 
-The `stomp-websockets` example shows how to configure ActiveMQ server to
+The `stomp-websockets` example shows how to configure Apache ActiveMQ server to
 have web browsers and Java applications exchanges messages on a JMS
 topic.
 
@@ -218,10 +218,10 @@ topic.
 [StompConnect](http://stomp.codehaus.org/StompConnect) is a server that
 can act as a Stomp broker and proxy the Stomp protocol to the standard
 JMS API. Consequently, using StompConnect it is possible to turn
-ActiveMQ into a Stomp Broker and use any of the available stomp clients.
+Apache ActiveMQ into a Stomp Broker and use any of the available stomp clients.
 These include clients written in C, C++, c\# and .net etc.
 
-To run StompConnect first start the ActiveMQ server and make sure that
+To run StompConnect first start the Apache ActiveMQ server and make sure that
 it is using JNDI.
 
 Stomp requires the file `jndi.properties` to be available on the
@@ -233,7 +233,7 @@ Configure any required JNDI resources in this file according to the
 documentation.
 
 Make sure this file is in the classpath along with the StompConnect jar
-and the ActiveMQ jars and simply run `java org.codehaus.stomp.jms.Main`.
+and the Apache ActiveMQ jars and simply run `java org.codehaus.stomp.jms.Main`.
 
 ## REST
 
@@ -241,7 +241,7 @@ Please see [Rest Interface](rest.md)
 
 ## AMQP
 
-ActiveMQ supports the [AMQP
+Apache ActiveMQ supports the [AMQP
 1.0](https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=amqp)
 specification. To enable AMQP you must configure a Netty Acceptor to
 receive AMQP clients, like so:
@@ -249,7 +249,7 @@ receive AMQP clients, like so:
     <acceptor name="stomp-acceptor">tcp://localhost:5672?protocols=AMQP</acceptor>
 
 
-ActiveMQ will then accept AMQP 1.0 clients on port 5672 which is the
+Apache ActiveMQ will then accept AMQP 1.0 clients on port 5672 which is the
 default AMQP port.
 
 There are 2 Stomp examples available see proton-j and proton-ruby which
@@ -257,18 +257,18 @@ use the qpid Java and Ruby clients respectively
 
 ### AMQP and security
 
-The ActiveMQ Server accepts AMQP SASL Authentication and will use this
+The Apache ActiveMQ Server accepts AMQP SASL Authentication and will use this
 to map onto the underlying session created for the connection so you can
-use the normal ActiveMQ security configuration.
+use the normal Apache ActiveMQ security configuration.
 
 ### AMQP Links
 
 An AMQP Link is a uni directional transport for messages between a
-source and a target, i.e. a client and the ActiveMQ Broker. A link will
+source and a target, i.e. a client and the Apache ActiveMQ Broker. A link will
 have an endpoint of which there are 2 kinds, a Sender and A Receiver. At
-the Broker a Sender will have its messages converted into a ActiveMQ
+the Broker a Sender will have its messages converted into an Apache ActiveMQ
 Message and forwarded to its destination or target. A Receiver will map
-onto a ActiveMQ Server Consumer and convert ActiveMQ messages back into
+onto an Apache ActiveMQ Server Consumer and convert Apache ActiveMQ messages back into
 AMQP messages before being delivered.
 
 ### AMQP and destinations
@@ -294,27 +294,27 @@ or committed via the coordinator.
 > **Note**
 >
 > AMQP allows the use of multiple transactions per session,
-> `amqp:multi-txns-per-ssn`, however in this version ActiveMQ will only
+> `amqp:multi-txns-per-ssn`, however in this version Apache ActiveMQ will only
 > support single transactions per session
 
 ## OpenWire
 
-ActiveMQ now supports the
+Apache ActiveMQ now supports the
 [OpenWire](http://activemq.apache.org/openwire.html) protocol so that an
-ActiveMQ JMS client can talk directly to a ActiveMQ server. To enable
+Apache ActiveMQ JMS client can talk directly to an Apache ActiveMQ server. To enable
 OpenWire support you must configure a Netty Acceptor, like so:
 
     <acceptor name="openwire-acceptor">tcp://localhost:61616?protocols=OPENWIRE</acceptor>
 
 
-The ActiveMQ server will then listens on port 61616 for incoming
+The Apache ActiveMQ server will then listens on port 61616 for incoming
 openwire commands. Please note the "protocols" is not mandatory here.
-The openwire configuration conforms to ActiveMQ's "Single Port" feature.
+The openwire configuration conforms to Apache ActiveMQ's "Single Port" feature.
 Please refer to [Configuring Single
 Port](#configuring-transports.single-port) for details.
 
 Please refer to the openwire example for more coding details.
 
-Currently we support ActiveMQ clients that using standard JMS APIs. In
-the future we will get more supports for some advanced, ActiveMQ
-specific features into ActiveMQ.
+Currently we support Apache ActiveMQ clients that using standard JMS APIs. In
+the future we will get more supports for some advanced, Apache ActiveMQ
+specific features into Apache ActiveMQ.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/jms-bridge.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/jms-bridge.md b/docs/user-manual/en/jms-bridge.md
index 6c0c0ec..e169975 100644
--- a/docs/user-manual/en/jms-bridge.md
+++ b/docs/user-manual/en/jms-bridge.md
@@ -1,6 +1,6 @@
 # The JMS Bridge
 
-ActiveMQ includes a fully functional JMS message bridge.
+Apache ActiveMQ includes a fully functional JMS message bridge.
 
 The function of the bridge is to consume messages from a source queue or
 topic, and send them to a target queue or topic, typically on a
@@ -8,18 +8,18 @@ different server.
 
 > *Notice:*
 > The JMS Bridge is not intended as a replacement for transformation and more expert systems such as Camel.
-> The JMS Bridge may be useful for fast transfers as this chapter covers, but keep in mind that more complex scenarios requiring transformations will require you to use a more advanced transformation system that will play on use cases that will go beyond ActiveMQ.
+> The JMS Bridge may be useful for fast transfers as this chapter covers, but keep in mind that more complex scenarios requiring transformations will require you to use a more advanced transformation system that will play on use cases that will go beyond Apache ActiveMQ.
 
 The source and target servers do not have to be in the same cluster
 which makes bridging suitable for reliably sending messages from one
 cluster to another, for instance across a WAN, and where the connection
 may be unreliable.
 
-A bridge can be deployed as a standalone application, with ActiveMQ
+A bridge can be deployed as a standalone application, with Apache ActiveMQ
 standalone server or inside a JBoss AS instance. The source and the
 target can be located in the same virtual machine or another one.
 
-The bridge can also be used to bridge messages from other non ActiveMQ
+The bridge can also be used to bridge messages from other non Apache ActiveMQ
 JMS servers, as long as they are JMS 1.1 compliant.
 
 > **Note**
@@ -27,7 +27,7 @@ JMS servers, as long as they are JMS 1.1 compliant.
 > Do not confuse a JMS bridge with a core bridge. A JMS bridge can be
 > used to bridge any two JMS 1.1 compliant JMS providers and uses the
 > JMS API. A core bridge (described in [Core Bidges](core-bridges.md)) is used to bridge any two
-> ActiveMQ instances and uses the core API. Always use a core bridge if
+> Apache ActiveMQ instances and uses the core API. Always use a core bridge if
 > you can in preference to a JMS bridge. The core bridge will typically
 > provide better performance than a JMS bridge. Also the core bridge can
 > provide *once and only once* delivery guarantees without using XA.
@@ -193,7 +193,7 @@ by the parameters passed to its constructor.
 
 The "transactionManager" property points to a JTA transaction manager
 implementation and should be set if you need to use the 'ONCE_AND_ONCE_ONLY'
-Quality of Service. ActiveMQ doesn't ship with such an implementation, but
+Quality of Service. Apache ActiveMQ doesn't ship with such an implementation, but
 if you are running within an Application Server you can inject the Transaction
 Manager that is shipped.
 
@@ -204,7 +204,7 @@ the connection factory used to create the connection for the source or
 target server.
 
 The configuration example above uses the default implementation provided
-by ActiveMQ that looks up the connection factory using JNDI. For other
+by Apache ActiveMQ that looks up the connection factory using JNDI. For other
 Application Servers or JMS providers a new implementation may have to be
 provided. This can easily be done by implementing the interface
 `org.apache.activemq.jms.bridge.ConnectionFactoryFactory`.
@@ -215,7 +215,7 @@ Again, similarly, these are used to create or lookup up the
 destinations.
 
 In the configuration example above, we have used the default provided by
-ActiveMQ that looks up the destination using JNDI.
+Apache ActiveMQ that looks up the destination using JNDI.
 
 A new implementation can be provided by implementing
 `org.apache.activemq.jms.bridge.DestinationFactory` interface.
@@ -251,7 +251,7 @@ This mode is available for both durable and non-durable messages.
 
 This QoS mode ensures messages will reach the destination from the
 source once and only once. (Sometimes this mode is known as "exactly
-once"). If both the source and the destination are on the same ActiveMQ
+once"). If both the source and the destination are on the same Apache ActiveMQ
 server instance then this can be achieved by sending and acknowledging
 the messages in the same local transaction. If the source and
 destination are on different servers this is achieved by enlisting the
@@ -307,4 +307,4 @@ you will have to bear in mind timeout issues.
 Please see [the examples chapter](examples.md) which shows how to configure and use a JMS Bridge with
 JBoss AS to send messages to the source destination and consume them
 from the target destination and how to configure and use a JMS Bridge between
-two standalone ActiveMQ servers.
+two standalone Apache ActiveMQ servers.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/jms-core-mapping.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/jms-core-mapping.md b/docs/user-manual/en/jms-core-mapping.md
index 19ff8a4..40190fa 100644
--- a/docs/user-manual/en/jms-core-mapping.md
+++ b/docs/user-manual/en/jms-core-mapping.md
@@ -1,9 +1,9 @@
 # Mapping JMS Concepts to the Core API
 
-This chapter describes how JMS destinations are mapped to ActiveMQ
+This chapter describes how JMS destinations are mapped to Apache ActiveMQ
 addresses.
 
-ActiveMQ core is JMS-agnostic. It does not have any concept of a JMS
+Apache ActiveMQ core is JMS-agnostic. It does not have any concept of a JMS
 topic. A JMS topic is implemented in core as an address (the topic name)
 with zero or more queues bound to it. Each queue bound to that address
 represents a topic subscription. Likewise, a JMS queue is implemented as

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/large-messages.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/large-messages.md b/docs/user-manual/en/large-messages.md
index 5799ce7..403bffb 100644
--- a/docs/user-manual/en/large-messages.md
+++ b/docs/user-manual/en/large-messages.md
@@ -1,6 +1,6 @@
 # Large Messages
 
-ActiveMQ supports sending and receiving of huge messages, even when the
+Apache ActiveMQ supports sending and receiving of huge messages, even when the
 client and server are running with limited memory. The only realistic
 limit to the size of a message that can be sent or consumed is the
 amount of disk space you have available. We have tested sending and
@@ -8,7 +8,7 @@ consuming messages up to 8 GiB in size with a client and server running
 in just 50MiB of RAM!
 
 To send a large message, the user can set an `InputStream` on a message
-body, and when that message is sent, ActiveMQ will read the
+body, and when that message is sent, Apache ActiveMQ will read the
 `InputStream`. A `FileInputStream` could be used for example to send a
 huge message from a huge file on disk.
 
@@ -52,9 +52,9 @@ determined by the parameter `minLargeMessageSize`
 
 > **Note**
 >
-> ActiveMQ messages are encoded using 2 bytes per character so if the
+> Apache ActiveMQ messages are encoded using 2 bytes per character so if the
 > message data is filled with ASCII characters (which are 1 byte) the
-> size of the resulting ActiveMQ message would roughly double. This is
+> size of the resulting Apache ActiveMQ message would roughly double. This is
 > important when calculating the size of a "large" message as it may
 > appear to be less than the `minLargeMessageSize` before it is sent,
 > but it then turns into a "large" message once it is encoded.
@@ -63,7 +63,7 @@ The default value is 100KiB.
 
 ### Using Core API
 
-If the ActiveMQ Core API is used, the minimal large message size is
+If the Apache ActiveMQ Core API is used, the minimal large message size is
 specified by `ServerLocator.setMinLargeMessageSize`.
 
 ``` java
@@ -125,7 +125,7 @@ by default:
 
 ## Streaming large messages
 
-ActiveMQ supports setting the body of messages using input and output
+Apache ActiveMQ supports setting the body of messages using input and output
 streams (`java.lang.io`)
 
 These streams are then used directly for sending (input streams) and
@@ -213,7 +213,7 @@ _HQ_LARGE_SIZE.
 
 ### Streaming over JMS
 
-When using JMS, ActiveMQ maps the streaming methods on the core API (see
+When using JMS, Apache ActiveMQ maps the streaming methods on the core API (see
 ClientMessage API table above) by setting object properties . You can use the method
 `Message.setObjectProperty` to set the input and output streams.
 
@@ -264,7 +264,7 @@ messageReceived.setObjectProperty("JMS_HQ_OutputStream", bufferedOutput);
 ## Streaming Alternative
 
 If you choose not to use the `InputStream` or `OutputStream` capability
-of ActiveMQ You could still access the data directly in an alternative
+of Apache ActiveMQ You could still access the data directly in an alternative
 fashion.
 
 On the Core API just get the bytes of the body as you normally would.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/libaio.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/libaio.md b/docs/user-manual/en/libaio.md
index 1fda971..9d94837 100644
--- a/docs/user-manual/en/libaio.md
+++ b/docs/user-manual/en/libaio.md
@@ -1,6 +1,6 @@
 # Libaio Native Libraries
 
-ActiveMQ distributes a native library, used as a bridge between ActiveMQ
+Apache ActiveMQ distributes a native library, used as a bridge between Apache ActiveMQ
 and Linux libaio.
 
 `libaio` is a library, developed as part of the Linux kernel project.
@@ -11,13 +11,13 @@ when they have been processed.
 We use this in our high performance journal if configured to do so,
 please see [Persistence](persistence.md).
 
-These are the native libraries distributed by ActiveMQ:
+These are the native libraries distributed by Apache ActiveMQ:
 
 -   libActiveMQAIO32.so - x86 32 bits
 
 -   libActiveMQAIO64.so - x86 64 bits
 
-When using libaio, ActiveMQ will always try loading these files as long
+When using libaio, Apache ActiveMQ will always try loading these files as long
 as they are on the [library path](#using-server.library.path).
 
 ## Compiling the native libraries
@@ -87,5 +87,5 @@ libactivemq-native-RELEASE.so`. Simply move that file over
 `bin` with the proper rename [library
 path](#using-server.library.path).
 
-If you want to perform changes on the ActiveMQ libaio code, you could
+If you want to perform changes on the Apache ActiveMQ libaio code, you could
 just call make directly at the `native-src` directory.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/logging.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/logging.md b/docs/user-manual/en/logging.md
index d5eae39..cf184a4 100644
--- a/docs/user-manual/en/logging.md
+++ b/docs/user-manual/en/logging.md
@@ -1,6 +1,6 @@
 # Logging
 
-ActiveMQ uses the JBoss Logging framework to do its logging and is
+Apache ActiveMQ uses the JBoss Logging framework to do its logging and is
 configurable via the `logging.properties` file found in the
 configuration directories. This is configured by Default to log to both
 the console and to a file.
@@ -21,7 +21,7 @@ There are 6 loggers available which are as follows:
     <tbody>
     <tr>
         <td>org.jboss.logging</td>
-        <td>Logs any calls not handled by the ActiveMQ loggers</td>
+        <td>Logs any calls not handled by the Apache ActiveMQ loggers</td>
     </tr>
     <tr>
         <td>org.apache.activemq.core.server</td>
@@ -85,7 +85,7 @@ The following is a typical `logging.properties for a client`
 
     # Root logger level
     logger.level=INFO
-    # ActiveMQ logger levels
+    # Apache ActiveMQ logger levels
     logger.org.apache.activemq.core.server.level=INFO
     logger.org.apache.activemq.utils.level=INFO
     logger.org.apache.activemq.jms.level=DEBUG

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/management.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/management.md b/docs/user-manual/en/management.md
index 3478639..186410a 100644
--- a/docs/user-manual/en/management.md
+++ b/docs/user-manual/en/management.md
@@ -1,23 +1,23 @@
 # Management
 
-ActiveMQ has an extensive management API that allows a user to modify a
+Apache ActiveMQ has an extensive management API that allows a user to modify a
 server configuration, create new resources (e.g. JMS queues and topics),
 inspect these resources (e.g. how many messages are currently held in a
 queue) and interact with it (e.g. to remove messages from a queue). All
-the operations allows a client to *manage* ActiveMQ. It also allows
+the operations allows a client to *manage* Apache ActiveMQ. It also allows
 clients to subscribe to management notifications.
 
-There are 3 ways to manage ActiveMQ:
+There are 3 ways to manage Apache ActiveMQ:
 
 -   Using JMX -- JMX is the standard way to manage Java applications
 
--   Using the core API -- management operations are sent to ActiveMQ
+-   Using the core API -- management operations are sent to Apache ActiveMQ
     server using *core messages*
 
--   Using the JMS API -- management operations are sent to ActiveMQ
+-   Using the JMS API -- management operations are sent to Apache ActiveMQ
     server using *JMS messages*
 
-Although there are 3 different ways to manage ActiveMQ each API supports
+Although there are 3 different ways to manage Apache ActiveMQ each API supports
 the same functionality. If it is possible to manage a resource using JMX
 it is also possible to achieve the same result using Core messages or
 JMS messages.
@@ -33,7 +33,7 @@ API is the same.
 For each *managed resource*, there exists a Java interface describing
 what can be invoked for this type of resource.
 
-ActiveMQ exposes its managed resources in 2 packages:
+Apache ActiveMQ exposes its managed resources in 2 packages:
 
 -   *Core* resources are located in the
     `org.apache.activemq.api.core.management` package
@@ -53,7 +53,7 @@ messages, or JMS messages are used.
 
 ### Core Management API
 
-ActiveMQ defines a core management API to manage core resources. For
+Apache ActiveMQ defines a core management API to manage core resources. For
 full details of the API please consult the javadoc. In summary:
 
 #### Core Server Management
@@ -113,7 +113,7 @@ full details of the API please consult the javadoc. In summary:
 
 -   Retrieving the server configuration and attributes
 
-    The `ActiveMQServerControl` exposes ActiveMQ server configuration
+    The `ActiveMQServerControl` exposes Apache ActiveMQ server configuration
     through all its attributes (e.g. `getVersion()` method to retrieve
     the server's version, etc.)
 
@@ -235,7 +235,7 @@ messages with a given property.)
 
 #### Other Core Resources Management
 
-ActiveMQ allows to start and stop its remote resources (acceptors,
+Apache ActiveMQ allows to start and stop its remote resources (acceptors,
 diverts, bridges, etc.) so that a server can be taken off line for a
 given period of time without stopping it completely (e.g. if other
 management operations must be performed such as resolving heuristic
@@ -303,7 +303,7 @@ transactions). These resources are:
 
 ### JMS Management API
 
-ActiveMQ defines a JMS Management API to manage JMS *administrated
+Apache ActiveMQ defines a JMS Management API to manage JMS *administrated
 objects* (i.e. JMS queues, topics and connection factories).
 
 #### JMS Server Management
@@ -483,11 +483,11 @@ ObjectName `org.apache.activemq:module=JMS,type=Topic,name="<the topic
 
 ## Using Management Via JMX
 
-ActiveMQ can be managed using
+Apache ActiveMQ can be managed using
 [JMX](http://www.oracle.com/technetwork/java/javase/tech/javamanagement-140525.html).
 
-The management API is exposed by ActiveMQ using MBeans interfaces.
-ActiveMQ registers its resources with the domain `org.apache.activemq`.
+The management API is exposed by Apache ActiveMQ using MBeans interfaces.
+Apache ActiveMQ registers its resources with the domain `org.apache.activemq`.
 
 For example, the `ObjectName` to manage a JMS Queue `exampleQueue` is:
 
@@ -502,20 +502,20 @@ The MBean's `ObjectName` are built using the helper class
 also use `jconsole` to find the `ObjectName` of the MBeans you want to
 manage.
 
-Managing ActiveMQ using JMX is identical to management of any Java
+Managing Apache ActiveMQ using JMX is identical to management of any Java
 Applications using JMX. It can be done by reflection or by creating
 proxies of the MBeans.
 
 ### Configuring JMX
 
-By default, JMX is enabled to manage ActiveMQ. It can be disabled by
+By default, JMX is enabled to manage Apache ActiveMQ. It can be disabled by
 setting `jmx-management-enabled` to `false` in
 `activemq-configuration.xml`:
 
-    <!-- false to disable JMX management for ActiveMQ -->
+    <!-- false to disable JMX management for Apache ActiveMQ -->
     <jmx-management-enabled>false</jmx-management-enabled>
 
-If JMX is enabled, ActiveMQ can be managed locally using `jconsole`.
+If JMX is enabled, Apache ActiveMQ can be managed locally using `jconsole`.
 
 > **Note**
 >
@@ -525,9 +525,9 @@ If JMX is enabled, ActiveMQ can be managed locally using `jconsole`.
 > to configure the server for remote management (system properties must
 > be set in `run.sh` or `run.bat` scripts).
 
-By default, ActiveMQ server uses the JMX domain "org.apache.activemq".
-To manage several ActiveMQ servers from the *same* MBeanServer, the JMX
-domain can be configured for each individual ActiveMQ server by setting
+By default, Apache ActiveMQ server uses the JMX domain "org.apache.activemq".
+To manage several Apache ActiveMQ servers from the *same* MBeanServer, the JMX
+domain can be configured for each individual Apache ActiveMQ server by setting
 `jmx-domain` in `activemq-configuration.xml`:
 
     <!-- use a specific JMX domain for ActiveMQ MBeans -->
@@ -535,14 +535,14 @@ domain can be configured for each individual ActiveMQ server by setting
 
 #### MBeanServer configuration
 
-When ActiveMQ is run in standalone, it uses the Java Virtual Machine's
+When Apache ActiveMQ is run in standalone, it uses the Java Virtual Machine's
 `Platform MBeanServer` to register its MBeans. By default [Jolokia](http://www.jolokia.org/)
 is also deployed to allow access to the mbean server via rest.
 
 ### Example
 
 See the [chapters](examples.md) chapter for an example which shows how to use a remote connection to JMX
-and MBean proxies to manage ActiveMQ.
+and MBean proxies to manage Apache ActiveMQ.
 
 ### Exposing JMX using Jolokia
 
@@ -573,7 +573,7 @@ management API:
 -   The parameters of the management operation
 
 When such a management message is sent to the management address,
-ActiveMQ server will handle it, extract the information, invoke the
+Apache ActiveMQ server will handle it, extract the information, invoke the
 operation on the managed resources and send a *management reply* to the
 management message's reply-to address (specified by
 `ClientMessageImpl.REPLYTO_HEADER_NAME`).
@@ -642,7 +642,7 @@ be able to receive and handle management messages. This is also
 configured in activemq-configuration.xml:
 
     <!-- users with the admin role will be allowed to manage -->
-    <!-- ActiveMQ using management messages        -->
+    <!-- Apache ActiveMQ using management messages        -->
     <security-setting match="jms.queue.activemq.management">
        <permission type="manage" roles="admin" />
     </security-setting>
@@ -699,11 +699,11 @@ steps are the same (see Configuring Core Management section).
 ### Example
 
 See the [examples](examples.md) chapter for an example which shows
-how to use JMS messages to manage the ActiveMQ server.
+how to use JMS messages to manage the Apache ActiveMQ server.
 
 ## Management Notifications
 
-ActiveMQ emits *notifications* to inform listeners of potentially
+Apache ActiveMQ emits *notifications* to inform listeners of potentially
 interesting events (creation of new resources, security violation,
 etc.).
 
@@ -728,7 +728,7 @@ subscribing to 2 MBeans:
 
 ### Core Messages Notifications
 
-ActiveMQ defines a special *management notification address*. Core
+Apache ActiveMQ defines a special *management notification address*. Core
 queues can be bound to this address so that clients will receive
 management notifications as Core messages
 
@@ -755,7 +755,7 @@ By default, the address is `activemq.notifications`.
 
 ### JMS Messages Notifications
 
-ActiveMQ's notifications can also be received using JMS messages.
+Apache ActiveMQ's notifications can also be received using JMS messages.
 
 It is similar to receiving notifications using Core API but an important
 difference is that JMS requires a JMS Destination to receive the
@@ -900,7 +900,7 @@ header. The timestamp is the un-formatted result of a call to
 ## Message Counters
 
 Message counters can be used to obtain information on queues *over time*
-as ActiveMQ keeps a history on queue metrics.
+as Apache ActiveMQ keeps a history on queue metrics.
 
 They can be used to show *trends* on queues. For example, using the
 management API, it would be possible to query the number of messages in
@@ -973,7 +973,7 @@ Message counters can be retrieved using the Management API. For example,
 to retrieve message counters on a JMS Queue using JMX:
 
 ``` java
-// retrieve a connection to ActiveMQ's MBeanServer
+// retrieve a connection to Apache ActiveMQ's MBeanServer
 MBeanServerConnection mbsc = ...
 JMSQueueControlMBean queueControl = (JMSQueueControl)MBeanServerInvocationHandler.newProxyInstance(mbsc,
    on,

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/message-expiry.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/message-expiry.md b/docs/user-manual/en/message-expiry.md
index e7dd973..8f81b83 100644
--- a/docs/user-manual/en/message-expiry.md
+++ b/docs/user-manual/en/message-expiry.md
@@ -2,18 +2,18 @@
 
 Messages can be set with an optional *time to live* when sending them.
 
-ActiveMQ will not deliver a message to a consumer after it's time to
+Apache ActiveMQ will not deliver a message to a consumer after it's time to
 live has been exceeded. If the message hasn't been delivered by the time
 that time to live is reached the server can discard it.
 
-ActiveMQ's addresses can be assigned a expiry address so that, when
+Apache ActiveMQ's addresses can be assigned a expiry address so that, when
 messages are expired, they are removed from the queue and sent to the
 expiry address. Many different queues can be bound to an expiry address.
 These *expired* messages can later be consumed for further inspection.
 
 ## Message Expiry
 
-Using ActiveMQ Core API, you can set an expiration time directly on the
+Using Apache ActiveMQ Core API, you can set an expiration time directly on the
 message:
 
     // message will expire in 5000ms from now

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/message-grouping.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/message-grouping.md b/docs/user-manual/en/message-grouping.md
index d5806ea..4787edf 100644
--- a/docs/user-manual/en/message-grouping.md
+++ b/docs/user-manual/en/message-grouping.md
@@ -5,7 +5,7 @@ characteristics:
 
 -   Messages in a message group share the same group id, i.e. they have
     same group identifier property (`JMSXGroupID` for JMS,
-    `_HQ_GROUP_ID` for ActiveMQ Core API).
+    `_HQ_GROUP_ID` for Apache ActiveMQ Core API).
 
 -   Messages in a message group are always consumed by the same
     consumer, even if there are many consumers on a queue. They pin all

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/messaging-concepts.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/messaging-concepts.md b/docs/user-manual/en/messaging-concepts.md
index e963d2a..40bf861 100644
--- a/docs/user-manual/en/messaging-concepts.md
+++ b/docs/user-manual/en/messaging-concepts.md
@@ -1,6 +1,6 @@
 # Messaging Concepts
 
-ActiveMQ is an asynchronous messaging system, an example of [Message
+Apache ActiveMQ is an asynchronous messaging system, an example of [Message
 Oriented
 Middleware](http://en.wikipedia.org/wiki/Message_oriented_middleware) ,
 we'll just call them messaging systems in the remainder of this book.
@@ -140,7 +140,7 @@ require.
 ## Transactions
 
 Messaging systems typically support the sending and acknowledgement of
-multiple messages in a single local transaction. ActiveMQ also supports
+multiple messages in a single local transaction. Apache ActiveMQ also supports
 the sending and acknowledgement of message as part of a large global
 transaction - using the Java mapping of XA: JTA.
 
@@ -184,7 +184,7 @@ programmatic API so JMS clients and servers from different vendors
 cannot directly interoperate since each will use the vendor's own
 internal wire protocol.
 
-ActiveMQ provides a fully compliant JMS 1.1 and JMS 2.0 API.
+Apache ActiveMQ provides a fully compliant JMS 1.1 and JMS 2.0 API.
 
 ### System specific APIs
 
@@ -194,7 +194,7 @@ of system functionality to be exposed to the client application. API's
 like JMS are not normally rich enough to expose all the extra features
 that most messaging systems provide.
 
-ActiveMQ provides its own core client API for clients to use if they
+Apache ActiveMQ provides its own core client API for clients to use if they
 wish to have access to functionality over and above that accessible via
 the JMS API.
 
@@ -216,7 +216,7 @@ use HTTP as their underlying protocol.
 The advantage of a REST approach with HTTP is in its simplicity and the
 fact the internet is already tuned to deal with HTTP optimally.
 
-Please see [Rest Interface](rest.md) for using ActiveMQ's RESTful interface.
+Please see [Rest Interface](rest.md) for using Apache ActiveMQ's RESTful interface.
 
 ### STOMP
 
@@ -226,7 +226,7 @@ theoretically any Stomp client can work with any messaging system that
 supports Stomp. Stomp clients are available in many different
 programming languages.
 
-Please see [Stomp](interoperability.md) for using STOMP with ActiveMQ.
+Please see [Stomp](interoperability.md) for using STOMP with Apache ActiveMQ.
 
 ### AMQP
 
@@ -235,10 +235,10 @@ interoperable messaging. It also defines a wire format, so any AMQP
 client can work with any messaging system that supports AMQP. AMQP
 clients are available in many different programming languages.
 
-ActiveMQ implements the [AMQP
+Apache ActiveMQ implements the [AMQP
 1.0](https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=amqp)
 specification. Any client that supports the 1.0 specification will be
-able to interact with ActiveMQ.
+able to interact with Apache ActiveMQ.
 
 ## High Availability
 
@@ -246,7 +246,7 @@ High Availability (HA) means that the system should remain operational
 after failure of one or more of the servers. The degree of support for
 HA varies between various messaging systems.
 
-ActiveMQ provides automatic failover where your sessions are
+Apache ActiveMQ provides automatic failover where your sessions are
 automatically reconnected to the backup server on event of live server
 failure.
 
@@ -263,12 +263,12 @@ Degrees of support for clusters varies between messaging systems, with
 some systems having fairly basic clusters with the cluster members being
 hardly aware of each other.
 
-ActiveMQ provides very configurable state-of-the-art clustering model
+Apache ActiveMQ provides very configurable state-of-the-art clustering model
 where messages can be intelligently load balanced between the servers in
 the cluster, according to the number of consumers on each node, and
 whether they are ready for messages.
 
-ActiveMQ also has the ability to automatically redistribute messages
+Apache ActiveMQ also has the ability to automatically redistribute messages
 between nodes of a cluster to prevent starvation on any particular node.
 
 For full details on clustering, please see [Clusters](clusters.md).
@@ -284,10 +284,10 @@ messages to another queue on a different server. Bridges cope with
 unreliable connections, automatically reconnecting when the connections
 becomes available again.
 
-ActiveMQ bridges can be configured with filter expressions to only
+Apache ActiveMQ bridges can be configured with filter expressions to only
 forward certain messages, and transformation can also be hooked in.
 
-ActiveMQ also allows routing between queues to be configured in server
+Apache ActiveMQ also allows routing between queues to be configured in server
 side configuration. This allows complex routing networks to be set up
 forwarding or copying messages from one destination to another, forming
 a global network of interconnected brokers.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/paging.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/paging.md b/docs/user-manual/en/paging.md
index 92b21d5..09e4695 100644
--- a/docs/user-manual/en/paging.md
+++ b/docs/user-manual/en/paging.md
@@ -1,17 +1,17 @@
 # Paging
 
-ActiveMQ transparently supports huge queues containing millions of
+Apache ActiveMQ transparently supports huge queues containing millions of
 messages while the server is running with limited memory.
 
 In such a situation it's not possible to store all of the queues in
-memory at any one time, so ActiveMQ transparently *pages* messages into
+memory at any one time, so Apache ActiveMQ transparently *pages* messages into
 and out of memory as they are needed, thus allowing massive queues with
 a low memory footprint.
 
-ActiveMQ will start paging messages to disk, when the size of all
+Apache ActiveMQ will start paging messages to disk, when the size of all
 messages in memory for an address exceeds a configured maximum size.
 
-By default, ActiveMQ does not page messages - this must be explicitly
+By default, Apache ActiveMQ does not page messages - this must be explicitly
 configured to activate it.
 
 ## Page Files
@@ -52,7 +52,7 @@ Global paging parameters are specified on the main configuration file
 
   Property Name        Description                                                                                                                 Default
   -------------------- --------------------------------------------------------------------------------------------------------------------------- -------------
-  `paging-directory`   Where page files are stored. ActiveMQ will create one folder for each address being paged under this configured location.   data/paging
+  `paging-directory`   Where page files are stored. Apache ActiveMQ will create one folder for each address being paged under this configured location.   data/paging
 
   : Paging Configuration Parameters
 
@@ -183,4 +183,4 @@ undesirable state.
 
 ## Example
 
-See the [examples](examples.md) chapter for an example which shows how to use paging with ActiveMQ.
+See the [examples](examples.md) chapter for an example which shows how to use paging with Apache ActiveMQ.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/perf-tuning.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/perf-tuning.md b/docs/user-manual/en/perf-tuning.md
index a245a13..81132b1 100644
--- a/docs/user-manual/en/perf-tuning.md
+++ b/docs/user-manual/en/perf-tuning.md
@@ -1,6 +1,6 @@
 # Performance Tuning
 
-In this chapter we'll discuss how to tune ActiveMQ for optimum
+In this chapter we'll discuss how to tune Apache ActiveMQ for optimum
 performance.
 
 ## Tuning persistence
@@ -72,12 +72,12 @@ JMS API
     storage.
 
 -   Batch many sends or acknowledgements in a single transaction.
-    ActiveMQ will only require a network round trip on the commit, not
+    Apache ActiveMQ will only require a network round trip on the commit, not
     on every send or acknowledgement.
 
 ## Other Tunings
 
-There are various other places in ActiveMQ where we can perform some
+There are various other places in Apache ActiveMQ where we can perform some
 tuning:
 
 -   Use Asynchronous Send Acknowledgements. If you need to send durable
@@ -125,7 +125,7 @@ tuning:
     consumer-window-size. This effectively disables consumer flow
     control.
 
--   Socket NIO vs Socket Old IO. By default ActiveMQ uses old (blocking)
+-   Socket NIO vs Socket Old IO. By default Apache ActiveMQ uses old (blocking)
     on the server and the client side (see the chapter on configuring
     transports for more information [Configuring the Transport](configuring-transports.md). NIO is much more scalable but
     can give you some latency hit compared to old blocking IO. If you
@@ -174,7 +174,7 @@ tuning:
     `serveruser`.
 
 -   Use `batch-delay` and set `direct-deliver` to false for the best
-    throughput for very small messages. ActiveMQ comes with a
+    throughput for very small messages. Apache ActiveMQ comes with a
     preconfigured connector/acceptor pair (`netty-throughput`) in
     `activemq-configuration.xml` and JMS connection factory
     (`ThroughputConnectionFactory`) in `activemq-jms.xml`which can be
@@ -193,7 +193,7 @@ tunings won't apply to JDKs from other providers (e.g. IBM or JRockit)
     `-XX:+UseParallelOldGC` on Sun JDKs.
 
 -   Memory settings. Give as much memory as you can to the server.
-    ActiveMQ can run in low memory by using paging (described in [Paging](paging.md)) but
+    Apache ActiveMQ can run in low memory by using paging (described in [Paging](paging.md)) but
     if it can run with all queues in RAM this will improve performance.
     The amount of memory you require will depend on the size and number
     of your queues and the size and number of your messages. Use the JVM
@@ -223,7 +223,7 @@ tunings won't apply to JDKs from other providers (e.g. IBM or JRockit)
     > Some popular libraries such as the Spring JMS Template are known
     > to use these anti-patterns. If you're using Spring JMS Template
     > and you're getting poor performance you know why. Don't blame
-    > ActiveMQ! The Spring JMS Template can only safely be used in an
+    > Apache ActiveMQ! The Spring JMS Template can only safely be used in an
     > app server which caches JMS sessions (e.g. using JCA), and only
     > then for sending messages. It cannot be safely be used for
     > synchronously consuming messages, even in an app server.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/persistence.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/persistence.md b/docs/user-manual/en/persistence.md
index 44e0375..bf59939 100644
--- a/docs/user-manual/en/persistence.md
+++ b/docs/user-manual/en/persistence.md
@@ -1,14 +1,14 @@
 # Persistence
 
-In this chapter we will describe how persistence works with ActiveMQ and
+In this chapter we will describe how persistence works with Apache ActiveMQ and
 how to configure it.
 
-ActiveMQ ships with a high performance journal. Since ActiveMQ handles
+Apache ActiveMQ ships with a high performance journal. Since Apache ActiveMQ handles
 its own persistence, rather than relying on a database or other 3rd
 party persistence engine it is very highly optimised for the specific
 messaging use cases.
 
-A ActiveMQ journal is an *append only* journal. It consists of a set of
+An Apache ActiveMQ journal is an *append only* journal. It consists of a set of
 files on disk. Each file is pre-created to a fixed size and initially
 filled with padding. As operations are performed on the server, e.g. add
 message, update message, delete message, records are appended to the
@@ -27,12 +27,12 @@ minimise the amount of disk head movement, since an entire disk cylinder
 is accessible simply by the disk rotating - the head does not have to
 move.
 
-As delete records are added to the journal, ActiveMQ has a sophisticated
+As delete records are added to the journal, Apache ActiveMQ has a sophisticated
 file garbage collection algorithm which can determine if a particular
 journal file is needed any more - i.e. has all its data been deleted in
 the same or other files. If so, the file can be reclaimed and re-used.
 
-ActiveMQ also has a compaction algorithm which removes dead space from
+Apache ActiveMQ also has a compaction algorithm which removes dead space from
 the journal and compresses up the data so it takes up less files on
 disk.
 
@@ -41,7 +41,7 @@ supporting both local and XA transactions.
 
 The majority of the journal is written in Java, however we abstract out
 the interaction with the actual file system to allow different pluggable
-implementations. ActiveMQ ships with two implementations:
+implementations. Apache ActiveMQ ships with two implementations:
 
 -   Java [NIO](http://en.wikipedia.org/wiki/New_I/O).
 
@@ -52,7 +52,7 @@ implementations. ActiveMQ ships with two implementations:
 -   Linux Asynchronous IO
 
     The second implementation uses a thin native code wrapper to talk to
-    the Linux asynchronous IO library (AIO). With AIO, ActiveMQ will be
+    the Linux asynchronous IO library (AIO). With AIO, Apache ActiveMQ will be
     called back when the data has made it to disk, allowing us to avoid
     explicit syncs altogether and simply send back confirmation of
     completion when AIO informs us that the data has been persisted.
@@ -73,7 +73,7 @@ implementations. ActiveMQ ships with two implementations:
 
     libaio is part of the kernel project.
 
-The standard ActiveMQ core server uses two instances of the journal:
+The standard Apache ActiveMQ core server uses two instances of the journal:
 
 -   Bindings journal.
 
@@ -107,7 +107,7 @@ The standard ActiveMQ core server uses two instances of the journal:
     This journal instance stores all message related data, including the
     message themselves and also duplicate-id caches.
 
-    By default ActiveMQ will try and use an AIO journal. If AIO is not
+    By default Apache ActiveMQ will try and use an AIO journal. If AIO is not
     available, e.g. the platform is not Linux with the correct kernel
     version or AIO has not been installed then it will automatically
     fall back to using Java NIO which is available on any Java platform.
@@ -116,13 +116,13 @@ The standard ActiveMQ core server uses two instances of the journal:
     has a `hq` extension. File size is by the default `10485760`
     (configurable), and it is located at the journal folder.
 
-For large messages, ActiveMQ persists them outside the message journal.
+For large messages, Apache ActiveMQ persists them outside the message journal.
 This is discussed in [Large Messages](large-messages.md).
 
-ActiveMQ can also be configured to page messages to disk in low memory
+Apache ActiveMQ can also be configured to page messages to disk in low memory
 situations. This is discussed in [Paging](paging.md).
 
-If no persistence is required at all, ActiveMQ can also be configured
+If no persistence is required at all, Apache ActiveMQ can also be configured
 not to persist any data at all to storage as discussed in the Configuring
 HornetQ for Zero Persistence section.
 
@@ -182,18 +182,18 @@ The message journal is configured using the following attributes in
 
     Choosing `NIO` chooses the Java NIO journal. Choosing `AIO` chooses
     the Linux asynchronous IO journal. If you choose `AIO` but are not
-    running Linux or you do not have libaio installed then ActiveMQ will
+    running Linux or you do not have libaio installed then Apache ActiveMQ will
     detect this and automatically fall back to using `NIO`.
 
 -   `journal-sync-transactional`
 
-    If this is set to true then ActiveMQ will make sure all transaction
+    If this is set to true then Apache ActiveMQ will make sure all transaction
     data is flushed to disk on transaction boundaries (commit, prepare
     and rollback). The default value is `true`.
 
 -   `journal-sync-non-transactional`
 
-    If this is set to true then ActiveMQ will make sure non
+    If this is set to true then Apache ActiveMQ will make sure non
     transactional message data (sends and acknowledgements) are flushed
     to disk each time. The default value for this is `true`.
 
@@ -204,8 +204,8 @@ The message journal is configured using the following attributes in
 
 -   `journal-min-files`
 
-    The minimum number of files the journal will maintain. When ActiveMQ
-    starts and there is no initial message data, ActiveMQ will
+    The minimum number of files the journal will maintain. When Apache ActiveMQ
+    starts and there is no initial message data, Apache ActiveMQ will
     pre-create `journal-min-files` number of files.
 
     Creating journal files and filling them with padding is a fairly
@@ -322,7 +322,7 @@ The message journal is configured using the following attributes in
 ## Installing AIO
 
 The Java NIO journal gives great performance, but If you are running
-ActiveMQ using Linux Kernel 2.6 or later, we highly recommend you use
+Apache ActiveMQ using Linux Kernel 2.6 or later, we highly recommend you use
 the `AIO` journal for the very best persistence performance.
 
 It's not possible to use the AIO journal under other operating systems
@@ -339,10 +339,10 @@ Using aptitude, (e.g. on Ubuntu or Debian system):
 
     apt-get install libaio
 
-## Configuring ActiveMQ for Zero Persistence
+## Configuring Apache ActiveMQ for Zero Persistence
 
 In some situations, zero persistence is sometimes required for a
-messaging system. Configuring ActiveMQ to perform zero persistence is
+messaging system. Configuring Apache ActiveMQ to perform zero persistence is
 straightforward. Simply set the parameter `persistence-enabled` in
 `activemq-configuration.xml` to `false`.
 
@@ -353,7 +353,7 @@ message data, duplicate id caches or paging data will be persisted.
 ## Import/Export the Journal Data
 
 You may want to inspect the existent records on each one of the journals
-used by ActiveMQ, and you can use the export/import tool for that
+used by Apache ActiveMQ, and you can use the export/import tool for that
 purpose.
 you can export the journal as a text file by using this command:
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/pre-acknowledge.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/pre-acknowledge.md b/docs/user-manual/en/pre-acknowledge.md
index 80104b4..8ecf8e1 100644
--- a/docs/user-manual/en/pre-acknowledge.md
+++ b/docs/user-manual/en/pre-acknowledge.md
@@ -8,14 +8,14 @@ JMS specifies 3 acknowledgement modes:
 
 -   `DUPS_OK_ACKNOWLEDGE`
 
-ActiveMQ supports two additional modes: `PRE_ACKNOWLEDGE` and
+Apache ActiveMQ supports two additional modes: `PRE_ACKNOWLEDGE` and
 `INDIVIDUAL_ACKNOWLEDGE`
 
 In some cases you can afford to lose messages in event of failure, so it
 would make sense to acknowledge the message on the server *before*
 delivering it to the client.
 
-This extra mode is supported by ActiveMQ and will call it
+This extra mode is supported by Apache ActiveMQ and will call it
 *pre-acknowledge* mode.
 
 The disadvantage of acknowledging on the server before delivery is that

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/preface.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/preface.md b/docs/user-manual/en/preface.md
index 7dcda06..1efdcda 100644
--- a/docs/user-manual/en/preface.md
+++ b/docs/user-manual/en/preface.md
@@ -1,24 +1,24 @@
 # Preface
 
-What is ActiveMQ?
+What is Apache ActiveMQ?
 
--   ActiveMQ is an open source project to build a multi-protocol,
+-   Apache ActiveMQ is an open source project to build a multi-protocol,
     embeddable, very high performance, clustered, asynchronous messaging
     system.
 
--   ActiveMQ is an example of Message Oriented Middleware (MoM). For a
+-   Apache ActiveMQ is an example of Message Oriented Middleware (MoM). For a
     description of MoMs and other messaging concepts please see the [Messaging Concepts](messaging-concepts.md).
 
--   For answers to more questions about what ActiveMQ is and what it
+-   For answers to more questions about what Apache ActiveMQ is and what it
     isn't please visit the [FAQs wiki
     page](todo).
 
-Why use ActiveMQ? Here are just a few of the reasons:
+Why use Apache ActiveMQ? Here are just a few of the reasons:
 
--   100% open source software. ActiveMQ is licensed using the Apache
+-   100% open source software. Apache ActiveMQ is licensed using the Apache
     Software License v 2.0 to minimise barriers to adoption.
 
--   ActiveMQ is designed with usability in mind.
+-   Apache ActiveMQ is designed with usability in mind.
 
 -   Written in Java. Runs on any platform with a Java 8+ runtime, that's
     everything from Windows desktops to IBM mainframes.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/project-info.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/project-info.md b/docs/user-manual/en/project-info.md
index b6099ac..b602892 100644
--- a/docs/user-manual/en/project-info.md
+++ b/docs/user-manual/en/project-info.md
@@ -1,6 +1,6 @@
 # Project Information
 
-The official ActiveMQ project page is <http://activemq.apache.org//>.
+The official Apache ActiveMQ project page is <http://activemq.apache.org//>.
 
 ## Software Download
 
@@ -20,11 +20,11 @@ page:<http://activemq.apache.org/download.html>
 
 -   Follow us on [twitter](https://twitter.com/activemq)
 
--   ActiveMQ Git repository is <https://github.com/apache/activemq-6>
+-   Apache ActiveMQ Git repository is <https://github.com/apache/activemq-6>
 
 -   All release tags are available from
     <https://github.com/apache/activemq-6/releases>
 
 
 And many thanks to all our contributors, both old and new who helped
-create ActiveMQ.
+create Apache ActiveMQ.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/rest.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/rest.md b/docs/user-manual/en/rest.md
index 679f7fa..36fadb6 100644
--- a/docs/user-manual/en/rest.md
+++ b/docs/user-manual/en/rest.md
@@ -1,7 +1,7 @@
 # REST Interface
 
-The ActiveMQ REST interface allows you to leverage the reliability and
-scalability features of ActiveMQ over a simple REST/HTTP interface.
+The Apache ActiveMQ REST interface allows you to leverage the reliability and
+scalability features of Apache ActiveMQ over a simple REST/HTTP interface.
 Messages are produced and consumed by sending and receiving simple HTTP
 messages that contain the content you want to push around. For instance,
 here's a simple example of posting an order to an order processing queue
@@ -18,47 +18,47 @@ express as an HTTP message:
     </order>
 
 As you can see, we're just posting some arbitrary XML document to a URL.
-When the XML is received on the server is it processed within ActiveMQ
-as a JMS message and distributed through core ActiveMQ. Simple and easy.
+When the XML is received on the server is it processed within Apache ActiveMQ
+as a JMS message and distributed through core Apache ActiveMQ. Simple and easy.
 Consuming messages from a queue or topic looks very similar. We'll
 discuss the entire interface in detail later in this docbook.
 
 ## Goals of REST Interface
 
-Why would you want to use ActiveMQ's REST interface? What are the goals
+Why would you want to use Apache ActiveMQ's REST interface? What are the goals
 of the REST interface?
 
 -   Easily usable by machine-based (code) clients.
 
--   Zero client footprint. We want ActiveMQ to be usable by any
+-   Zero client footprint. We want Apache ActiveMQ to be usable by any
     client/programming language that has an adequate HTTP client
     library. You shouldn't have to download, install, and configure a
-    special library to interact with ActiveMQ.
+    special library to interact with Apache ActiveMQ.
 
 -   Lightweight interoperability. The HTTP protocol is strong enough to
     be our message exchange protocol. Since interactions are RESTful the
     HTTP uniform interface provides all the interoperability you need to
     communicate between different languages, platforms, and even
     messaging implementations that choose to implement the same RESTful
-    interface as ActiveMQ (i.e. the [REST-\*](http://rest-star.org)
+    interface as Apache ActiveMQ (i.e. the [REST-\*](http://rest-star.org)
     effort.)
 
 -   No envelope (e.g. SOAP) or feed (e.g. Atom) format requirements. You
     shouldn't have to learn, use, or parse a specific XML document
-    format in order to send and receive messages through ActiveMQ's REST
+    format in order to send and receive messages through Apache ActiveMQ's REST
     interface.
 
 -   Leverage the reliability, scalability, and clustering features of
-    ActiveMQ on the back end without sacrificing the simplicity of a
+    Apache ActiveMQ on the back end without sacrificing the simplicity of a
     REST interface.
 
 ## Installation and Configuration
 
-ActiveMQ's REST interface is installed as a Web archive (WAR). It depends on the [RESTEasy](http://jboss.org/resteasy) project and can currently only run within a servlet container. Installing the ActiveMQ REST interface is a little bit different depending whether ActiveMQ is already installed and configured for your environment (e.g. you're deploying within Wildfly) or you want the ActiveMQ REST WAR to startup and manage the ActiveMQ server (e.g. you're deploying within something like Apache Tomcat).
+Apache ActiveMQ's REST interface is installed as a Web archive (WAR). It depends on the [RESTEasy](http://jboss.org/resteasy) project and can currently only run within a servlet container. Installing the Apache ActiveMQ REST interface is a little bit different depending whether Apache ActiveMQ is already installed and configured for your environment (e.g. you're deploying within Wildfly) or you want the ActiveMQ REST WAR to startup and manage the Apache ActiveMQ server (e.g. you're deploying within something like Apache Tomcat).
 
 ### Installing Within Pre-configured Environment
 
-This section should be used when you want to use the ActiveMQ REST interface in an environment that already has ActiveMQ installed and running, e.g. the Wildfly application server. You must create a Web archive (.WAR) file with the following web.xml settings:
+This section should be used when you want to use the Apache ActiveMQ REST interface in an environment that already has Apache ActiveMQ installed and running, e.g. the Wildfly application server. You must create a Web archive (.WAR) file with the following web.xml settings:
 
     <web-app>
        <listener>
@@ -86,7 +86,7 @@ This section should be used when you want to use the ActiveMQ REST interface in
        </filter-mapping>
     </web-app>
 
-Within your WEB-INF/lib directory you must have the activemq-rest.jar file. If RESTEasy is not installed within your environment, you must add the RESTEasy jar files within the lib directory as well. Here's a sample Maven pom.xml that can build a WAR with the ActiveMQ REST library.
+Within your WEB-INF/lib directory you must have the Apache activemq-rest.jar file. If RESTEasy is not installed within your environment, you must add the RESTEasy jar files within the lib directory as well. Here's a sample Maven pom.xml that can build a WAR with the Apache ActiveMQ REST library.
 
     <project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -128,7 +128,7 @@ It is worth noting that when deploying a WAR in a Java EE application server lik
 
 ### Bootstrapping ActiveMQ Along with REST
 
-You can bootstrap ActiveMQ within your WAR as well. To do this, you must have the ActiveMQ core and JMS jars along with Netty, RESTEasy, and the ActiveMQ REST jar within your WEB-INF/lib. You must also have a activemq-configuration.xml config file within WEB-INF/classes. The examples that come with the ActiveMQ REST distribution show how to do this. You must also add an additional listener to your web.xml file. Here's an example:
+You can bootstrap Apache ActiveMQ within your WAR as well. To do this, you must have the Apache ActiveMQ core and JMS jars along with Netty, RESTEasy, and the Apache ActiveMQ REST jar within your WEB-INF/lib. You must also have an Apache ActiveMQ-configuration.xml config file within WEB-INF/classes. The examples that come with the Apache ActiveMQ REST distribution show how to do this. You must also add an additional listener to your web.xml file. Here's an example:
 
     <web-app>
        <listener>
@@ -162,7 +162,7 @@ You can bootstrap ActiveMQ within your WAR as well. To do this, you must have th
        </filter-mapping>
     </web-app>
 
-Here's a Maven pom.xml file for creating a WAR for this environment. Make sure your ActiveMQ configuration file(s) are within the src/main/resources directory so that they are stuffed within the WAR's WEB-INF/classes directory!
+Here's a Maven pom.xml file for creating a WAR for this environment. Make sure your Apache ActiveMQ configuration file(s) are within the src/main/resources directory so that they are stuffed within the WAR's WEB-INF/classes directory!
 
     <project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -197,7 +197,7 @@ The project structure should look this like:
 
 ### REST Configuration
 
-The ActiveMQ REST implementation does have some configuration options.
+The Apache ActiveMQ REST implementation does have some configuration options.
 These are configured via XML configuration file that must be in your
 WEB-INF/classes directory. You must set the web.xml context-param
 `rest.messaging.config.file` to specify the name of the configuration
@@ -220,12 +220,12 @@ values for each.
 
 Let's give an explanation of each config option.
 
--   `server-in-vm-id`. The ActiveMQ REST impl uses the IN-VM transport
-    to communicate with ActiveMQ. It uses the default server id, which
+-   `server-in-vm-id`. The Apache ActiveMQ REST impl uses the IN-VM transport
+    to communicate with Apache ActiveMQ. It uses the default server id, which
     is "0".
 
 -   `use-link-headers`. By default, all links (URLs) are published using
-    custom headers. You can instead have the ActiveMQ REST
+    custom headers. You can instead have the Apache ActiveMQ REST
     implementation publish links using the [Link Header
     specification](http://tools.ietf.org/html/draft-nottingham-http-link-header-10)
     instead if you desire.
@@ -244,7 +244,7 @@ Let's give an explanation of each config option.
     system path. This is a directory where push registrations for queues
     are stored. See [Pushing Messages](#message-push).
 
--   `producer-session-pool-size`. The REST implementation pools ActiveMQ
+-   `producer-session-pool-size`. The REST implementation pools Apache ActiveMQ
     sessions for sending messages. This is the size of the pool. That
     number of sessions will be created at startup time.
 
@@ -260,12 +260,12 @@ Let's give an explanation of each config option.
     consumers/subscriptions that remain idle for that amount of time.
 
 -   `consumer-window-size`. For consumers, this config option is the
-    same as the ActiveMQ one of the same name. It will be used by
-    sessions created by the ActiveMQ REST implementation.
+    same as the Apache ActiveMQ one of the same name. It will be used by
+    sessions created by the Apache ActiveMQ REST implementation.
 
-## ActiveMQ REST Interface Basics
+## Apache ActiveMQ REST Interface Basics
 
-The ActiveMQ REST interface publishes a variety of REST resources to
+The Apache ActiveMQ REST interface publishes a variety of REST resources to
 perform various tasks on a queue or topic. Only the top-level queue and
 topic URI schemes are published to the outside world. You must discover
 all over resources to interact with by looking for and traversing links.
@@ -280,7 +280,7 @@ following relative URI pattern:
     /queues/{name}
     /topics/{name}
 
-The base of the URI is the base URL of the WAR you deployed the ActiveMQ
+The base of the URI is the base URL of the WAR you deployed the Apache ActiveMQ
 REST server within as defined in the [Installation and
 Configuration](#install) section of this document. Replace the `{name}`
 string within the above URI pattern with the name of the queue or topic
@@ -288,7 +288,7 @@ you are interested in interacting with. For example if you have
 configured a JMS topic named "foo" within your `activemq-jms.xml` file,
 the URI name should be "jms.topic.foo". If you have configured a JMS
 queue name "bar" within your `activemq-jms.xml` file, the URI name
-should be "jms.queue.bar". Internally, ActiveMQ prepends the "jms.topic"
+should be "jms.queue.bar". Internally, Apache ActiveMQ prepends the "jms.topic"
 or "jms.queue" strings to the name of the deployed destination. Next,
 perform your HEAD or GET request on this URI. Here's what a
 request/response would look like.
@@ -317,7 +317,7 @@ on the scheme of the URLs returned within these headers as they are an
 implementation detail. Treat them as opaque and query for them each and
 every time you initially interact (at boot time) with the server. If you
 treat all URLs as opaque then you will be isolated from implementation
-changes as the ActiveMQ REST interface evolves over time.
+changes as the Apache ActiveMQ REST interface evolves over time.
 
 ### Queue Resource Response Headers
 
@@ -336,7 +336,7 @@ with a Queue resource.
     [Consuming Messages via Pull](#message-pull).
 
 -   `msg-push-consumers`. This is a URL for registering other URLs you
-    want the ActiveMQ REST server to push messages to. The semantics of
+    want the Apache ActiveMQ REST server to push messages to. The semantics of
     this link are described in [Pushing Messages](#message-push).
 
 ### Topic Resource Response Headers
@@ -356,19 +356,19 @@ with a Topic resource.
     described in [Consuming Messages via Pull](#message-pull).
 
 -   `msg-push-subscriptions`. This is a URL for registering other URLs
-    you want the ActiveMQ REST server to push messages to. The semantics
+    you want the Apache ActiveMQ REST server to push messages to. The semantics
     of this link are described in [Pushing Messages](#message-push).
 
 ## Posting Messages
 
 This chapter discusses the protocol for posting messages to a queue or a
-topic. In [ActiveMQ REST Interface Basics](#basics), you saw that a
+topic. In [Apache ActiveMQ REST Interface Basics](#basics), you saw that a
 queue or topic resource publishes variable custom headers that are links
 to other RESTful resources. The `msg-create` header is a URL you can
 post a message to. Messages are published to a queue or topic by sending
 a simple HTTP message to the URL published by the `msg-create` header.
 The HTTP message contains whatever content you want to publish to the
-ActiveMQ destination. Here's an example scenario:
+Apache ActiveMQ destination. Here's an example scenario:
 
 > **Note**
 >
@@ -450,10 +450,10 @@ Sometimes you might have network problems when posting new messages to a
 queue or topic. You may do a POST and never receive a response.
 Unfortunately, you don't know whether or not the server received the
 message and so a re-post of the message might cause duplicates to be
-posted to the queue or topic. By default, the ActiveMQ REST interface is
+posted to the queue or topic. By default, the Apache ActiveMQ REST interface is
 configured to accept and post duplicate messages. You can change this by
 turning on duplicate message detection by setting the `dups-ok` config
-option to `false` as described in [ActiveMQ REST Interface
+option to `false` as described in [Apache ActiveMQ REST Interface
 Basics](#basics). When you do this, the initial POST to the `msg-create`
 URL will redirect you, using the standard HTTP 307 redirection mechanism
 to a unique URL to POST to. All other interactions remain the same as
@@ -531,17 +531,17 @@ discussed earlier. Here's an example:
     in the `msg-create-next` header.
 
 How can this work? As you can see, with each successful response, the
-ActiveMQ REST server returns a uniquely generated URL within the
+Apache ActiveMQ REST server returns a uniquely generated URL within the
 msg-create-next header. This URL is dedicated to the next new message
 you want to post. Behind the scenes, the code extracts an identify from
-the URL and uses ActiveMQ's duplicate detection mechanism by setting the
+the URL and uses Apache ActiveMQ's duplicate detection mechanism by setting the
 `DUPLICATE_DETECTION_ID` property of the JMS message that is actually
 posted to the system.
 
 If you happen to use the same ID more than once you'll see a message
 like this on the server:
 
-    WARN  [org.apache.activemq.core.server] (Thread-3 (ActiveMQ-remoting-threads-ActiveMQServerImpl::serverUUID=8d6be6f8-5e8b-11e2-80db-51bbde66f473-26319292-267207)) HQ112098: Duplicate message detected - message will not be routed. Message information:
+    WARN  [org.apache.activemq.core.server] (Thread-3 (Apache ActiveMQ-remoting-threads-ActiveMQServerImpl::serverUUID=8d6be6f8-5e8b-11e2-80db-51bbde66f473-26319292-267207)) HQ112098: Duplicate message detected - message will not be routed. Message information:
     ServerMessage[messageID=20,priority=4, bodySize=1500,expiration=0, durable=true, address=jms.queue.bar,properties=TypedProperties[{http_content$type=application/x-www-form-urlencoded, http_content$length=3, postedAsHttpMessage=true, _HQ_DUPL_ID=42}]]@12835058
 
 An alternative to this approach is to use the `msg-create-with-id`
@@ -568,7 +568,7 @@ repost the message. It also only has to come up with a unique
 ### Persistent Messages
 
 By default, posted messages are not durable and will not be persisted in
-ActiveMQ's journal. You can create durable messages by modifying the
+Apache ActiveMQ's journal. You can create durable messages by modifying the
 default configuration as expressed in Chapter 2 so that all messages are
 persisted when sent. Alternatively, you can set a URL query parameter
 called `durable` to true when you post your messages to the URLs
@@ -615,14 +615,14 @@ almost identically for queues and topics with some minor, but important
 caveats. To start consuming you must create a consumer resource on the
 server that is dedicated to your client. Now, this pretty much breaks
 the stateless principle of REST, but after much prototyping, this is the
-best way to work most effectively with ActiveMQ through a REST
+best way to work most effectively with Apache ActiveMQ through a REST
 interface.
 
 You create consumer resources by doing a simple POST to the URL
 published by the `msg-pull-consumers` response header if you are
 interacting with a queue, the `msg-pull-subscribers` response header if
 you're interacting with a topic. These headers are provided by the main
-queue or topic resource discussed in [ActiveMQ REST Interface
+queue or topic resource discussed in [Apache ActiveMQ REST Interface
 Basics](#basics). Doing an empty POST to one of these URLs will create a
 consumer resource that follows an auto-acknowledge protocol and, if you
 are interacting with a topic, creates a temporarily subscription to the
@@ -642,7 +642,7 @@ parameters (`application/x-www-form-urlencoded`) described below.
     provide this parameter, the name will be automatically generated by
     the server. Only usable on topics.
 
--   `selector`. This is an optional JMS selector string. The ActiveMQ
+-   `selector`. This is an optional JMS selector string. The Apache ActiveMQ
     REST interface adds HTTP headers to the JMS message for REST
     produced messages. HTTP headers are prefixed with "http\_" and every
     '-' character is converted to a '\$'.
@@ -810,7 +810,7 @@ resource.
     retry a post. Also notice, that another new msg-consume-next URL is
     present. Although it probably is the same URL you used last post,
     get in the habit of using URLs returned in response headers as
-    future versions of ActiveMQ REST might be redirecting you or adding
+    future versions of Apache ActiveMQ REST might be redirecting you or adding
     additional data to the URL after timeouts like this.
 
 3.  POST to the URL within the last `msg-consume-next` to get the next
@@ -1063,7 +1063,7 @@ request on the consumer resource.
 Unless your queue or topic has a high rate of message flowing though it,
 if you use the pull protocol, you're going to be receiving a lot of 503
 responses as you continuously pull the server for new messages. To
-alleviate this problem, the ActiveMQ REST interface provides the
+alleviate this problem, the Apache ActiveMQ REST interface provides the
 `Accept-Wait` header. This is a generic HTTP request header that is a
 hint to the server for how long the client is willing to wait for a
 response from the server. The value of this header is the time in
@@ -1098,9 +1098,9 @@ server-side consumer resource (and underlying JMS session).
 
 ## Pushing Messages
 
-You can configure the ActiveMQ REST server to push messages to a
+You can configure the Apache ActiveMQ REST server to push messages to a
 registered URL either remotely through the REST interface, or by
-creating a pre-configured XML file for the ActiveMQ REST server to load
+creating a pre-configured XML file for the Apache ActiveMQ REST server to load
 at boot time.
 
 ### The Queue Push Subscription XML
@@ -1145,7 +1145,7 @@ performing a retry.
 The `disableOnFailure` element, if set to true, will disable the
 registration if all retries have failed. It will not disable the
 connection on non-connection-failure issues (like a bad request for
-instance). In these cases, the dead letter queue logic of ActiveMQ will
+instance). In these cases, the dead letter queue logic of Apache ActiveMQ will
 take over.
 
 The `link` element specifies the basis of the interaction. The `href`
@@ -1158,10 +1158,10 @@ important and the value of it triggers different behavior. Here's the
 values a rel attribute can have:
 
 -   `destination`. The href URL is assumed to be a queue or topic
-    resource of another ActiveMQ REST server. The push registration will
+    resource of another Apache ActiveMQ REST server. The push registration will
     initially do a HEAD request to this URL to obtain a
     msg-create-with-id header. It will use this header to push new
-    messages to the ActiveMQ REST endpoint reliably. Here's an example:
+    messages to the Apache ActiveMQ REST endpoint reliably. Here's an example:
 
         <push-registration>
            <link rel="destination" href="http://somewhere.com/queues/jms.queue.foo"/>
@@ -1368,19 +1368,19 @@ Here's what creating a topic would look like:
     HTTP/1.1 201 Created
     Location: http://example.com/topics/jms.topic.testTopic
 
-## Securing the ActiveMQ REST Interface
+## Securing the Apache ActiveMQ REST Interface
 
 ### Within Wildfly Application server
 
-Securing the ActiveMQ REST interface is very simple with the Wildfly
+Securing the Apache ActiveMQ REST interface is very simple with the Wildfly
 Application Server. You turn on authentication for all URLs within your
-WAR's web.xml, and let the user Principal to propagate to ActiveMQ. This
-only works if you are using the JAASSecurityManager with ActiveMQ. See
-the ActiveMQ documentation for more details.
+WAR's web.xml, and let the user Principal to propagate to Apache ActiveMQ. This
+only works if you are using the JAASSecurityManager with Apache ActiveMQ. See
+the Apache ActiveMQ documentation for more details.
 
 ### Security in other environments
 
-To secure the ActiveMQ REST interface in other environments you must
+To secure the Apache ActiveMQ REST interface in other environments you must
 role your own security by specifying security constraints with your
 web.xml for every path of every queue and topic you have deployed. Here
 is a list of URI patterns:
@@ -1430,7 +1430,7 @@ is a list of URI patterns:
 
 ## Mixing JMS and REST
 
-The ActiveMQ REST interface supports mixing JMS and REST producers and
+The Apache ActiveMQ REST interface supports mixing JMS and REST producers and
 consumers. You can send an ObjectMessage through a JMS Producer, and
 have a REST client consume it. You can have a REST client POST a message
 to a topic and have a JMS Consumer receive it. Some simple
@@ -1439,10 +1439,10 @@ installed.
 
 ### JMS Producers - REST Consumers
 
-If you have a JMS producer, the ActiveMQ REST interface only supports
+If you have a JMS producer, the Apache ActiveMQ REST interface only supports
 ObjectMessage type. If the JMS producer is aware that there may be REST
 consumers, it should set a JMS property to specify what Content-Type the
-Java object should be translated into by REST clients. The ActiveMQ REST
+Java object should be translated into by REST clients. The Apache ActiveMQ REST
 server will use RESTEasy content handlers (MessageBodyReader/Writers) to
 transform the Java object to the type desired. Here's an example of a
 JMS producer setting the content type of the message.
@@ -1460,7 +1460,7 @@ push registration should be set to the desired type.
 ### REST Producers - JMS Consumers
 
 If you have a REST client producing messages and a JMS consumer,
-ActiveMQ REST has a simple helper class for you to transform the HTTP
+Apache ActiveMQ REST has a simple helper class for you to transform the HTTP
 body to a Java object. Here's some example code:
 
     public void onMessage(Message message)

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/security.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/security.md b/docs/user-manual/en/security.md
index 9e49adf..8998ba4 100644
--- a/docs/user-manual/en/security.md
+++ b/docs/user-manual/en/security.md
@@ -1,6 +1,6 @@
 # Security
 
-This chapter describes how security works with ActiveMQ and how you can
+This chapter describes how security works with Apache ActiveMQ and how you can
 configure it. To disable security completely simply set the
 `security-enabled` property to false in the `activemq-configuration.xml`
 file.
@@ -12,15 +12,15 @@ is `10000` ms.
 
 ## Role based security for addresses
 
-ActiveMQ contains a flexible role-based security model for applying
+Apache ActiveMQ contains a flexible role-based security model for applying
 security to queues, based on their addresses.
 
-As explained in [Using Core](using-core.md), ActiveMQ core consists mainly of sets of queues bound
+As explained in [Using Core](using-core.md), Apache ActiveMQ core consists mainly of sets of queues bound
 to addresses. A message is sent to an address and the server looks up
 the set of queues that are bound to that address, the server then routes
 the message to those set of queues.
 
-ActiveMQ allows sets of permissions to be defined against the queues
+Apache ActiveMQ allows sets of permissions to be defined against the queues
 based on their address. An exact match on the address can be used or a
 wildcard match can be used using the wildcard characters '`#`' and
 '`*`'.
@@ -83,7 +83,7 @@ these addresses or consume messages from queues bound to an address that
 starts with the string "globalqueues.europe."
 
 The mapping between a user and what roles they have is handled by the
-security manager. ActiveMQ ships with a user manager that reads user
+security manager. Apache ActiveMQ ships with a user manager that reads user
 credentials from a file on disk, and can also plug into JAAS or JBoss
 Application Server security.
 
@@ -124,14 +124,14 @@ in sub-groups of addresses.
 
 When messaging clients are connected to servers, or servers are
 connected to other servers (e.g. via bridges) over an untrusted network
-then ActiveMQ allows that traffic to be encrypted using the Secure
+then Apache ActiveMQ allows that traffic to be encrypted using the Secure
 Sockets Layer (SSL) transport.
 
 For more information on configuring the SSL transport, please see [Configuring the Transport](configuring-transports.md).
 
 ## Basic user credentials
 
-ActiveMQ ships with a security manager implementation that reads user
+Apache ActiveMQ ships with a security manager implementation that reads user
 credentials, i.e. user names, passwords and role information from properties
 files on the classpath called `activemq-users.properties` and `activemq-roles.properties`. This is the default security manager.
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/send-guarantees.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/send-guarantees.md b/docs/user-manual/en/send-guarantees.md
index 44aef11..a441337 100644
--- a/docs/user-manual/en/send-guarantees.md
+++ b/docs/user-manual/en/send-guarantees.md
@@ -2,7 +2,7 @@
 
 ## Guarantees of Transaction Completion
 
-When committing or rolling back a transaction with ActiveMQ, the request
+When committing or rolling back a transaction with Apache ActiveMQ, the request
 to commit or rollback is sent to the server, and the call will block on
 the client side until a response has been received from the server that
 the commit or rollback was executed.
@@ -27,7 +27,7 @@ This parameter is set in `activemq-configuration.xml`
 ## Guarantees of Non Transactional Message Sends
 
 If you are sending messages to a server using a non transacted session,
-ActiveMQ can be configured to block the call to send until the message
+Apache ActiveMQ can be configured to block the call to send until the message
 has definitely reached the server, and a response has been sent back to
 the client. This can be configured individually for durable and
 non-durable messages, and is determined by the following two parameters:
@@ -49,7 +49,7 @@ network round trip time (RTT) of your network, rather than the bandwidth
 of your network. For better performance we recommend either batching
 many messages sends together in a transaction since with a transactional
 session, only the commit / rollback blocks not every send, or, using
-ActiveMQ's advanced *asynchronous send acknowledgements feature*
+Apache ActiveMQ's advanced *asynchronous send acknowledgements feature*
 described in Asynchronous Send Acknowledgements.
 
 If you are using JMS and JNDI then using the elements
@@ -73,7 +73,7 @@ The default value for this parameter is `true`.
 ## Guarantees of Non Transactional Acknowledgements
 
 If you are acknowledging the delivery of a message at the client side
-using a non transacted session, ActiveMQ can be configured to block the
+using a non transacted session, Apache ActiveMQ can be configured to block the
 call to acknowledge until the acknowledge has definitely reached the
 server, and a response has been sent back to the client. This is
 configured with the parameter `BlockOnAcknowledge`. If this is set to
@@ -87,7 +87,7 @@ implement a strict *at most once* delivery policy. The default value is
 
 If you are using a non transacted session but want a guarantee that
 every message sent to the server has reached it, then, as discussed in
-Guarantees of Non Transactional Message Sends, you can configure ActiveMQ to block the call to send until the server
+Guarantees of Non Transactional Message Sends, you can configure Apache ActiveMQ to block the call to send until the server
 has received the message, persisted it and sent back a response. This
 works well but has a severe performance penalty - each call to send
 needs to block for at least the time of a network round trip (RTT) - the
@@ -108,8 +108,8 @@ messages are sent without blocking! These figures aren't an exact
 science but you can clearly see that being limited by network RTT can
 have serious effect on performance.
 
-To remedy this, ActiveMQ provides an advanced new feature called
-*asynchronous send acknowledgements*. With this feature, ActiveMQ can be
+To remedy this, Apache ActiveMQ provides an advanced new feature called
+*asynchronous send acknowledgements*. With this feature, Apache ActiveMQ can be
 configured to send messages without blocking in one direction and
 asynchronously getting acknowledgement from the server that the messages
 were received in a separate stream. By de-coupling the send from the
@@ -132,7 +132,7 @@ a handler instance on your `ClientSession`.
 Then, you just send messages as normal using your `ClientSession`, and
 as messages reach the server, the server will send back an
 acknowledgement of the send asynchronously, and some time later you are
-informed at the client side by ActiveMQ calling your handler's
+informed at the client side by Apache ActiveMQ calling your handler's
 `sendAcknowledged(ClientMessage message)` method, passing in a reference
 to the message that was sent.
 


Mime
View raw message