Merge pull request #341 from AxonIQ/feature/console-teasers

Add information about AxonIQ Console to the reference guide

Author: CodeDrivenMitch

.gitbook/assets/console/flow.png

@@ -10,13 +10,11 @@ Axon provides an innovative and powerful way of sensibly evolving to event-drive
 Please visit [the AxonIQ website](https://axoniq.io/) to learn more about AxonIQ and the Axon community. 
 There, you will find information about Axon training, support options, upcoming and past events.
 
-> Breaking Changes in Axon Framework 4.7!
-> 
-> Against our normal approach towards minor releases, we sadly had to introduce breaking changes between Axon Framework 4.6 and 4.7.
-> Our apologies for this.
-> 
-> To help you with your upgrade we have constructed a dedicated page [here](axon-framework/upgrading-to-4-7.md) that helps you on your path to upgrade to 4.7.
-> If you find any irregularities concerning your upgrade, be sure to reach out to us!
+> **Monitoring with AxonIQ Console**
+>
+> We have built a platform that makes it very easy to monitor your Axon Framework applications.  It measures everything in your applications, aggregates, metrics and processors.
+> ![../../.gitbook/assets/console/graphs.png](../../.gitbook/assets/console/graphs.png)
+> You can find more information on our [product page](https://www.axoniq.io/products/axoniq-console) or [log in directly](https://console.axoniq.io/).
 
 ## How to use this guide
 

.gitbook/assets/console/graphs.png

@@ -457,6 +457,11 @@ Once you resolve the problem that led to dead lettering events, we can start pro
 We recommend using the `SequencedDeadLetterProcessor` interface for this, as it processes an entire dead-letter _sequence_ instead of single dead-letter entries.
 It will thus ensure the event order is maintained during the retry.
 
+> **Processing Dead-Letters with AxonIQ Console**
+> 
+> With AxonIQ Console you can see and manage the items in your Dead-Letter Queue, as well as receive notifications when the queues contain items.
+> You can find more information on our [product page](https://www.axoniq.io/products/axoniq-console) or [log in directly](https://console.axoniq.io/).
+
 The `SequencedDeadLetterProcessor` provides two operations to process dead letters:
 
 1. `boolean processAny()` - Process the oldest dead-letter sequence.
@@ -740,3 +745,7 @@ It is the `RollbackConfiguration` that decide when a [Unit of Work](../../messag
 The default `RollbackConfiguration` is to rollback on any type of `Throwable`; the [Unit of Work](../../messaging-concepts/unit-of-work.md) page describes the other options you can choose.
 To adjust the default behaviour, the `registerRollbackConfiguration(String, Function<Configuration, RollbackConfiguration>)` function should be invoked on the `EventProcessingConfigurer`.
 
+### Configuration Overview
+Sometimes it can be hard to understand the current active configuration. For that, you can easily see an overview of the configuration of each Event Processor in [AxonIQ Console](https://www.axoniq.io/products/axoniq-console), once your application is connected to it. In addition the AxonIQ Console provides many more features for processors, such as being able to scale your event processor, and monitor the message handlers of your applications.
+
+

README.md

@@ -1304,10 +1304,11 @@ In turn, we can reduce the number of segments again if the load on the streaming
 To change the number of segments at runtime, the _split and merge_ operations should be used.
 Splitting and merging allow you to control the number of segments dynamically.
 
-There are roughly two approaches to adjust the number of segments for a streaming processor:
+There are roughly three approaches to adjust the number of segments for a streaming processor:
 
 1. Through the [Axon Server](../../../axon-server/introduction.md) Dashboard with the split and merge buttons
-2. Directly on a `StreamingEventProcessor`, with the `splitSegment(int segmentId)` and `mergeSegment(int segmentId)` methods
+2. Through the [AxonIQ Console](https://www.axoniq.io/products/axoniq-console) processor detail page, where you can also configure your segments to scale automatically.
+3. Directly on a `StreamingEventProcessor`, with the `splitSegment(int segmentId)` and `mergeSegment(int segmentId)` methods
 
 When Axon Server is in place, we recommend using option one since it is easiest to use.
 Whenever Axon Server is not used, and you want to adjust the number of segments, the split and merge methods should be accessible from within your application.
@@ -1465,10 +1466,10 @@ class StreamingProcessorController {
 > If you are in a [multi-node](#multi-node-processing) scenario, that means *all* nodes should shut down the `StreamingEventProcessor`.
 > Otherwise, another node will pick up the segments released by the inactive processor instance.
 > 
-> Being able to shut down or start up all streaming processor instances is most easily achieved through the [Axon Server](../../../axon-server/introduction.md) Dashboard.
+> Being able to shut down or start up all streaming processor instances is most easily achieved through the [Axon Server](../../../axon-server/introduction.md) Dashboard or through connecting your application to [AxonIQ Console](https://www.axoniq.io/products/axoniq-console).
 > The application's dashboard provides a "start" and "stop" button, which will start/stop the processor on every node.
 > 
-> When Axon Server is not used, you should construct a custom endpoint in your application.
+> When not using Axon Server or AxonIQ Console, you should construct a custom endpoint in your application.
 > The `StreamingProcessorService` sample shared above would be ideal for adding a start and stop method. 
 
 ### Replay API
@@ -1544,7 +1545,6 @@ The `CardSummaryProjection` shows a couple of interesting things to take note of
    The type of the `resetContext` is up to the user and is the same context as is used for the `@ResetHandler` (see 4.). 
    The type of the `resetContext` has to match the parameter's, or it will be null.
 
-
 ## Multiple Event Sources
 
 You can configure a Streaming Event Processor to use multiple sources to process events from.

axon-framework/events/event-processors/README.md

@@ -2,16 +2,21 @@
 
 One of the core concepts in Axon is messaging. All communication between components is done using message objects. This gives these components the location transparency needed to be able to scale and distribute these components when necessary.‌
 
-Although all these messages implement the `Message` interface, there is a clear distinction between the different types of messages and how they are treated.‌
-
-All messages contain a payload, meta data and unique identifier. The payload of the message is the functional description of what the message means. The combination of the class name of this object and the data it carries, describe the application's meaning of the message. The metadata allows you to describe the context in which a message is being sent. You can, for example, store tracing information, to allow the origin or cause of messages to be tracked. You can also store information to describe the security context under which a command is being executed.‌
-
-​[Axon Coding Tutorial \#2: - The Core API](https://youtu.be/vnCxjWZrrk0)​
+Although all these messages implement the `Message` interface, there is a clear distinction between the different types of messages and how they are treated.
 
 > **Note**
 >
-> Note that all messages are immutable. Storing data in a message actually means creating a new message based on the previous one, with extra information added to it. This guarantees that messages are safe to use in a multi-threaded and distributed environment.
+> Note that all messages are immutable. Storing data in a message actually means creating a new message based on the previous one, with extra information added to it. This guarantees that messages are safe to use in a multi-threaded and distributed environment.‌
+
+All messages contain a payload, meta data and unique identifier. The payload of the message is the functional description of what the message means. The combination of the class name of this object and the data it carries, describe the application's meaning of the message. The metadata allows you to describe the context in which a message is being sent. You can, for example, store tracing information, to allow the origin or cause of messages to be tracked. You can also store information to describe the security context under which a command is being executed.
+
+AxonIQ Console can visualize this flow of messages for you without any additional configuration. 
+ ![../../.gitbook/assets/console/graphs.png](../../.gitbook/assets/console/flow.png)
+ You can find more information on our [product page](https://www.axoniq.io/products/axoniq-console) or [log in directly](https://console.axoniq.io/).
+
 
+## Tutorial <a id="tutorial"></a>
+We have recorded a tutorial video on Core API. You can find this  at [Axon Coding Tutorial \#2: - The Core API](https://youtu.be/vnCxjWZrrk0)​
 ‌
 
 ## Commands <a id="commands"></a>

axon-framework/events/event-processors/streaming.md

@@ -3,6 +3,12 @@
 The ability to monitor and measure what is going on is very important. 
 This section contains all information regarding metrics, tracing and monitoring of your Axon Framework application.
 
+> **Monitoring with AxonIQ Console**
+> 
+> We have built a platform that makes it very easy to monitor your Axon Framework applications.  It measures everything in your applications, aggregates, metrics and processors.
+> ![../../.gitbook/assets/console/graphs.png](../../.gitbook/assets/console/graphs.png)
+> You can find more information on our [product page](https://www.axoniq.io/products/axoniq-console) or [log in directly](https://console.axoniq.io/).
+
 A summary of the various subsections is given below.
 
 | Subsection                              | Purpose                                                           |

axon-framework/messaging-concepts/README.md

@@ -4,9 +4,9 @@ Typically, application components contain one or more[ Event Processors](../even
 
 ## Increasing and decreasing segment counts <a id="increasing-and-decreasing-segment-counts"></a>
 
-Tracking Event Processors that handle events in multiple threads use segments to separate the events in the stream across these threads in a reliable way. However, especially when these threads are spread across multiple instances of a component, and the number of instances changes, it may be useful to scale the number of segments accordingly.
+Streaming Event Processors that handle events in multiple threads use segments to separate the events in the stream across these threads in a reliable way. However, especially when these threads are spread across multiple instances of a component, and the number of instances changes, it may be useful to scale the number of segments accordingly.
 
-To this end, Axon Framework provides a [split and merge API](../events/event-processors/streaming.md#splitting-and-merging-segments). This API can be utilized directly via a client configuration or through Axon Server, where the latter takes required coordination into account.
+To this end, Axon Framework provides a [split and merge API](../events/event-processors/streaming.md#splitting-and-merging-segments). This API can be utilized directly via a client configuration, through Axon Server, or [AxonIQ Console](https://www.axoniq.io/products/axoniq-console), where the latter two takes required coordination into account.
 
 ### Segment tuning through Axon Framework <a id="segment-tuning-through-axon-framework"></a>
 

axon-framework/monitoring/README.md

@@ -6,6 +6,10 @@ When aggregates live for a long time, and their state constantly changes, they w
 
 For example, items in stock tend to change quite often. Each time an item is sold, an event reduces the stock by one. Every time a shipment of new items comes in, the stock is incremented by some larger number. If you sell a hundred items each day, you will produce at least 100 events per day. After a few days, your system will spend too much time reading in all these events just to find out whether it should raise an "ItemOutOfStockEvent". A single snapshot event could replace a lot of these events, just by storing the current number of items in stock.
 
+> **To measure it to know**
+>
+> [AxonIQ Console](https://www.axoniq.io/products/axoniq-console) can measure the amount of events that were loaded during command handling, so you know if you need to create snapshots or not!. It's also able to track many more interesting metrics, such as the load time of the aggregate, and the time it took to store the events. 
+
 ### Creating a snapshot
 
 Snapshot creation can be triggered by a number of factors, for example: the number of events created since the last snapshot, the time to initialize an aggregate exceeds a certain threshold, time-based, etc. Currently, Axon provides a mechanism that allows you to trigger snapshots based on an event count threshold.