Overview of Camel 4

Stats, major changes, new components and the CLI

Last week Apache Camel 4.14.0 was released. This version has the latest what the Java integration framework has to offer. It also safe to use because it will be supported as a long-term support version.

If you prefer a more conservative approach, you can use the previous LTS version, 4.10.x, which is rock solid. In short, if you have the opportunity, upgrade to Camel 4!

But besides being on the latest version, what does Camel 4 exactly has to offer? In this blog, we explore the changes since the release of version 4.0 in August 2023.

Stats

In addition to the major release in 2023, Camel 4 has had 14 minor releases. Five of these releases are LTS and also receive patch releases. That makes 40 releases in total!

On average, three issues are solved per day, for a total of 2,867 issues. Of those, 741 are bug fixes, 1,047 are improvements, and 337 are new features.

Details can be found in the table below:

What’s new?

In this section we provide 15 highlights, one for each release. As it’s impossible to highlight all important changes a link with the details of each release is provided for each release.

4.0

Camel 4 was released with Java 17 as the new baseline, and support for Java 21 soon followed in version 4.2. Camel 4 introduced a unified approach to configuring beans in Java, XML, and YAML. Here is an XML example:

<camel>

    <bean name="greeter" type="com.foo.Greeter">
        <properties>
            <property key="message" value="Hello World" />
        </properties>
    </bean>

    <route id="my-route">
        <from uri="direct:start"/>
        <bean ref="greeter"/>
        <to uri="mock:finish"/>
    </route>

</camel>

Apache Camel 4 What's New (top 10)

4.1

The first minor release saw continued performance improvements of the content-router, filter, seda, disrupter and more.

Also OpenTelemetryTracingStrategy was added that allows fine-grained tracing of every step a message is routed by Camel.

Apache Camel 4.1 What's New

4.2

Support for text blocks in the Java DSL:

from("""debezium-postgres:customerEvents
        ?databasePassword={{myPassword}}
        &databaseDbname=myDB
        &databaseHostname=myHost
        &pollIntervalMs=2000
        &queryFetchSize=100""")
    .to("kafka:cheese");

Apache Camel 4.2 What's New

4.3

Introduction of the setHeaders eip to set multiple headers at once.

<route>
    <from uri="direct:a"/>
    <setHeaders>
        <setHeader name="myHeader">
            <constant>test</constant>
        </setHeader>
        <setHeader name="otherHeader">
            <constant>other</constant>
        </setHeader>
    </setHeaders>
    <to uri="direct:b"/>
</route>

Apache Camel 4.3 What's New

4.4

Introduction of variables in Camel:

from("kafka:order.in")
  .setVariable("customerId", jq(".customer.custId"))
  .setVariable("country", jq(".customer.address.co"))
  .transform().simple("Order received from customer ${variable.customerId} in ${variable.country}")
  .to("kafka:order.event");

Here is a background article about variables:

Camel variables: new ways to manipulate data pipelines

Apache Camel 4.4 What's New

4.5

Support for environment profiles. For example camel-jbang runs in dev profile by default, and camel-main would run in prod profile by default.

Apache Camel 4.5 What's New

4.6

The Rest DSL gained support for a contract first approach. This mean you can create REST endpoints directly from an existing OpenAPI v3 specification file.

Apache Camel 4.6 What's New

4.7

Adds remote performance counters to CamelContext and Routes which counts only messages that are received from an endpoint that is remote.

Apache Camel 4.7 What's New

4.8

Introduces the poll EIP as an easier and simpler version of pollEnrich EIP which is also more tooling friendly.

Apache Camel 4.8 What's New

4.9

4.9 introduces Camel-Observability-Services, which aims to unify and harmonize observability configuration in Camel. It provides a set of default configurations that are consistent regardless of the runtime of choice.

Apache Camel 4.9 What's New

4.10

Support for AI.

Camel AI contains more then ten components including support for Langchain, ChatScript, Deep Java library, and vector databases like Milvus, Neo4j, Pinecone, Qdrant, and Weaviate.

Apache Camel 4.10 What's New

4.11

In this version a new abstract component for distributed telemetry was implemented. The camel-telemetry component and its concrete implementations (camel-telemetrydev, camel-opentelemetry2) will eventually replace camel-tracing components.

Apache Camel 4.11 What's New

4.12

Port 9876 has been designated as the common management port for all runtime, including Quarkus, Spring and Main. Also observability services are exposed over this port.

Apache Camel 4.12 What's New

4.13

Improvements of the request validator, for both the built-in and as well when using camel-openapi-validator component. The latter now validate the request payload is valid according to the OpenAPI schema.

Apache Camel 4.13 What's New

4.14

Latest LTS release.

It was already possible to label multiple routes that belong to a group:

from("activemq:queue:order.in")
    .routeId("validate")
    .group("order") 
    .to("bean:orderServer?method=validate")
    .to("direct:processOrder");

from("direct:processOrder")
    .routeId("process")
    .group("order")
    .to("bean:orderService?method=process")
    .to("activemq:queue:order.out");

In 4.14.0 the API was extended to perform tasks like getting all routes by group, starting and stopping of all routes in a group and use JMX management by group.

Route Group

The team also start preparing the code base for the upcoming Java 25 release.

Apache Camel 4.14 What's New

Camel CLI (JBang)

Camel JBang in Camel 4 introduces many significant improvements:

• Migration Tools: The transform command to convert Camel routes between DSLs (XML/YAML) and assist in migrating legacy OSGi blueprint and Spring XML files.
• CLI Debugger: The debug command offers a command-line interface for debugging Camel routes, including step-in/step-over functionality.
• Flexible Runtimes: camel run directly supports Spring Boot and Quarkus runtimes with the --runtime option.
• Enhanced Developer Experience:
• --dev mode for live reloading with run clipboard.yaml.
• JBang //DEPS comments for easy dependency declaration.
• Interactive --prompt for setting placeholder values during startup.
• Improved edit command with Camel coding assistance.
• A new interactive shell command for quick execution of JBang commands.
• Observability & Diagnostics:
• New get commands like get startup, get bean, get rest, get route --error, get kafka, and get properties provide comprehensive insights into running Camel applications.
• Plugin Ecosystem: Introduces support for plugins, with initial camel-k commands for managing Camel K integrations, and dedicated infra and update commands for managing external services and upgrading Camel versions.
• Kubernetes Integration: Major overhaul of the camel kubernetes plugin, with improved deployment, running, and export for all runtimes, and no longer dependent on Camel K.
• Camel Launcher: The Camel Launcher module provides a self-contained, ready-to-run version of Camel for command-line usage, eliminating the need for a separate JBang installation.

Try it yourself:

Camel JBang

New Components

Camel 4 has a many new components. Here list alphabetically with a short explanation what the component does:

• camel-activemq6 — JMS component that are preset for ActiveMQ 6.x
• camel-aws-bedrock — Invoke Model of AWS Bedrock service.
• camel-aws-bedrock-agent — Operate on AWS Bedrock through its Agent.
• camel-aws-bedrock-agent-runtime — Invoke Model of AWS Bedrock Agent Runtime service.
• camel-aws-config — Manage AWS Config service.
• camel-aws2-redshift-data — Perform operations on AWS Redshift using Redshift Data API.
• camel-aws2-step-functions — Manage and invoke AWS Step functions
• camel-aws2-timestream — A Camel Amazon Web Services TimeStream component
• camel-azure-files — Send and receive files on Azure File Storage
• camel-azure-schema-registry — Azure Schema Registry Component for utilities to deal with authentication.
• camel-clickup — Receives events from ClickUp
• camel-dapr — Dapr component which interfaces with Dapr Building Blocks.
• camel-dfdl — Transforms fixed format data such as EDI message from/to XML using a Data Format Description Language (DFDL)
• camel-dhis2 — Integrate with DHIS2 (health-level)
• camel-elasticsearch-rest-client — Perform queries and other operations on Elasticsearch or OpenSearch (uses low-level client)
• camel-flowable — Send and receive messages from the Flowable BPMN and CMMN engines
• camel-fury — Serialize and deserialize messages using Apache Fury
• camel-google-pubsub-lite — Send and receive messages to/from Google Cloud Platform PubSub Lite Service
• camel-iso8583 — Create, edit and read ISO-8583 messages
• camel-jandex — Custom class and resource loader using jandex.idx
• camel-jolokia-starter — To make using Jolokia easy with Camel Spring Boot
• camel-kubernetes-cronjob — Perform operations on Kubernetes CronJob
• camel-langchain4j-agent — AI Agent
• camel-langchain-chat — LangChain4j Chat component
• camel-langchain-embeddings — LangChain4j Embeddings
• camel-langchain4j-tokenizer — LangChain4j Tokenizer
• camel-langchain4j-tools — LangChain4j Tools and Function Calling Features
• camel-langchain4j-web-search — LangChain4j Web Search Engine
• camel-micrometer-prometheus — Camel Micrometer Prometheus for Camel Main
• camel-milvus — Perform operations on the Milvus Vector Database
• camel-oauth — Camel OAuth
• camel-observability-services — Opinionated observability for Camel on cloud
• camel-observation — Observability using Micrometer Observation
• camel-openapi-validator — OpenAPI validator for Camel Rest DSL (using Atlassian Validator Client)
• camel-opensearch — Send requests to OpenSearch
• camel-opentelemetry2 — Implementation of Camel OpenTelemetry based on the Camel Telemetry spec
• camel-parquet-avro — Parquet Avro serialization and de-serialization
• camel-pinecone — Perform operations on the Pinecone Vector Database
• camel-platform-http-jolokia — Jolokia plugin for standalone Camel HTTP Platform
• camel-platform-http-main — Platform HTTP for Camel Main runtime
• camel-pqc — Post Quantum Cryptography Signature and Verification component
• camel-qdrant — Perform operations on the Qdrant Vector Database
• camel-smb — Receive files from SMB (Server Message Block) shares.
• camel-smooks — Added smooks also as a data format for EDI, XML, CSV, etc. based data transformation
• camel-solr — Perform operations against Apache Lucene Solr
• camel-spring-cloud-config — Spring Vault support
• camel-tahu — Sparkplug B Host/Edge support over MQTT using Eclipse Tahu
• camel-telemetry — Distributed telemetry common interfaces
• camel-telemetry-dev — Basic implementation of Camel Telemetry useful for development purposes
• camel-thymeleaf — Transform messages using a Thymeleaf template
• camel-torchserve — Provide access to PyTorch TorchServe servers to run inference with PyTorch models remotely
• camel-wasm — Call a wasm (web assembly) function
• camel-weaviate — Perform operations on the Weaviate Vector Database
• camel-yaml-io — YAML DSL route dumper
• camel-zeebe — Integration with Camunda Zeebe
• ibm-secrets-manager — Manage secrets in IBM Secrets Manager Service

Migration

There is an extensive migration guide available:

Apache Camel 4.x Upgrade Guide

If you do it manually and upgrading from Camel 2 or 3 then it’s helpful first to upgrade to Camel 4 and then to the latest LTS version.

There is also an automatic upgrade process available by using OpenRewrite. The OpenRewrite recipes can be found here:

GitHub - apache/camel-upgrade-recipes: Apache Camel Upgrade Recipes Repository

Summary

Camel 4 brought main improvements in the following areas:

• Core API refinements and performance improvements
• Introduction of variables
• Improved observability
• New AI capabilities
• Better support for REST and OpenAPI
• Advanced CLI features

Conclusion

Apache Camel 4 represents a significant evolution of the framework, building on its core principles while introducing substantial updates and new features.

Whether you’re a new user or a long-time enthusiast, the new features, performance improvements, and enhanced support for enterprise patterns make upgrading to Camel 4 a compelling choice for building efficient and scalable integration solutions.

When you aren’t already on Camel 4, hopefully this overview gave you enough reasons to do so.