Chapter 6. Monitoring Camel K integrations

Procedure

1. Enter the following command to check if the cluster-monitoring-config ConfigMap object exists in the openshift-monitoring project:

   $ oc -n openshift-monitoring get configmap cluster-monitoring-config

2. Create the cluster-monitoring-config ConfigMap if this does not already exist:

   $ oc -n openshift-monitoring create configmap cluster-monitoring-config

3. Edit the cluster-monitoring-config ConfigMap:

   $ oc -n openshift-monitoring edit configmap cluster-monitoring-config

4. Under data:config.yaml:, set enableUserWorkload to true:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: cluster-monitoring-config
     namespace: openshift-monitoring
   data:
     config.yaml: |
       enableUserWorkload: true

Procedure

1. Enter the following command to run your Camel K integration with the Prometheus trait enabled:

   $ kamel run myIntegration.java -t prometheus.enabled=true

   Alternatively, you can enable the Prometheus trait globally once, by updating the integration platform as follows:

   $ oc patch ip camel-k --type=merge -p '{"spec":{"traits":{"prometheus":{"configuration":{"enabled":"true"}}}}}'

2. View monitoring of Camel K integration metrics in Prometheus. For example, for embedded Prometheus, select Monitoring > Metrics in the OpenShift administrator or developer web console.
3. Enter the Camel K metric that you want to view. For example, in the Administrator console, under Insert Metric at Cursor, enter application_camel_context_uptime_seconds, and click Run Queries.
4. Click Add Query to view additional metrics.

Procedure

1. Register the custom metrics in your Camel integration code using Camel MicroProfile Metrics component annotations. The following example shows a Metrics.java integration:

   // camel-k: language=java trait=prometheus.enabled=true dependency=mvn:org.my/app:1.0 1
   
   import org.apache.camel.Exchange;
   import org.apache.camel.LoggingLevel;
   import org.apache.camel.builder.RouteBuilder;
   import org.apache.camel.component.microprofile.metrics.MicroProfileMetricsConstants;
   
   import javax.enterprise.context.ApplicationScoped;
   
   @ApplicationScoped
   public class Metrics extends RouteBuilder {
   
      @Override
      public void configure() {
           onException()
               .handled(true)
               .maximumRedeliveries(2)
               .logStackTrace(false)
               .logExhausted(false)
               .log(LoggingLevel.ERROR, "Failed processing ${body}")
               // Register the 'redelivery' meter
               .to("microprofile-metrics:meter:redelivery?mark=2")
               // Register the 'error' meter
               .to("microprofile-metrics:meter:error"); 2
   
           from("timer:stream?period=1000")
               .routeId("unreliable-service")
               .setBody(header(Exchange.TIMER_COUNTER).prepend("event #"))
               .log("Processing ${body}...")
               // Register the 'generated' meter
               .to("microprofile-metrics:meter:generated") 3
               // Register the 'attempt' meter via @Metered in Service.java
               .bean("service") 4
               .filter(header(Exchange.REDELIVERED))
                   .log(LoggingLevel.WARN, "Processed ${body} after ${header.CamelRedeliveryCounter} retries")
                   .setHeader(MicroProfileMetricsConstants.HEADER_METER_MARK, header(Exchange.REDELIVERY_COUNTER))
                   // Register the 'redelivery' meter
                   .to("microprofile-metrics:meter:redelivery") 5
               .end()
               .log("Successfully processed ${body}")
               // Register the 'success' meter
               .to("microprofile-metrics:meter:success"); 6
       }
   }

   1

   Uses the Camel K modeline to automatically configure the Prometheus trait and Maven dependencies

   2

   error: Metric for the number of errors corresponding to the number of events that have not been processed

   3

   generated: Metric for the number of events to be processed

   4

   attempt: Metric for the number of calls made to the service bean to process incoming events

   5

   redelivery: Metric for the number of retries made to process the event

   6

   success: Metric for the number of events successfully processed

2. Add Camel MicroProfile Metrics annotations to any implementation files as needed. The following example shows the service bean called by the Camel K integration, which generates random failures:

   package com.redhat.integration;
   
   import java.util.Random;
   
   import org.apache.camel.Exchange;
   import org.apache.camel.RuntimeExchangeException;
   
   import org.eclipse.microprofile.metrics.Meter;
   import org.eclipse.microprofile.metrics.annotation.Metered;
   import org.eclipse.microprofile.metrics.annotation.Metric;
   
   import javax.inject.Named;
   import javax.enterprise.context.ApplicationScoped;
   
   @Named("service")
   @ApplicationScoped
   @io.quarkus.arc.Unremovable
   
   public class Service {
   
      //Register the attempt meter
      @Metered(absolute = true)
      public void attempt(Exchange exchange) { 1
         Random rand = new Random();
            if (rand.nextDouble() < 0.5) {
                throw new RuntimeExchangeException("Random failure", exchange); 2
         }
      }
    }

   1

   The @Metered MicroProfile Metrics annotation declares the meter and the name is automatically generated based on the metrics method name, in this case, attempt.

   2

   This example fails randomly to help generate errors for metrics.

3. Follow the steps in Section 6.2, “Configuring Camel K integration metrics” to run the integration and view the custom Camel K metrics in Prometheus.

   In this case, the example already uses the Camel K modeline in Metrics.java to automatically configure Prometheus and the required Maven dependencies for Service.java.