PortX, the Integration Platform as a Service (IPaaS) for financial institutions, is built on the open source Apache Camel framework. When leveraged correctly, Camel rivals the capabilities of expensive enterprise integration platforms while delivering the critical flexibility and security required in the financial industry. However, developing a financial-grade yet user-friendly platform on this powerful, evolving framework requires a team with intimate domain knowledge of Apache Camel and other integration platforms. Our engineers and architects possess the skills to master Camel’s functionality and work to make Camel and PortX more developer-friendly. In this blog, Eugene Berman, Senior Solutions Architect, shares our latest contribution – the Camel Debugger tool.
We recently demoed PortX to a prospective client who asked us what the debugging experience was like towards the end of our meeting. Unfortunately, at that time, it wasn’t possible to debug in Camel (we’ll get into that in a moment). At ModusBox, when something is “impossible,” it feels like a rock in our shoe. We pause, deal with the rock, and life is better. Moments like this become catalysts for change, and the Camel Debugger was no different.
We immediately reached out to our friend Claus Ibsen, Senior Principal Software Engineer at Red Hat and the Apache Software Foundation. Claus suggested we partner with his team to build two vital debugger components; Claus and his team started working on the abstraction of debugger services in Camel, while our team started developing the IDE (Integrated Development Environment) with IntelliJ IDEA. The result is Camel’s first Debugger, available today as a plugin and to be included in the v3.15 release in February.
Features included in the Camel Debugger
- Breakpoints inside Camel routes in XML DSL
- Conditional breakpoints with Simple language predicates
- Message body, headers, and Exchange properties preview
- Camel expressions evaluator
- Support for Simple and DataSonnet expression languages
- Message History and execution stack
- Step Over, Step Into, and Step Out functionalities implemented
- Run To Position implemented
- Camel and Camel SpringBoot run configurations
Why is the Camel Debugger a big deal?
Debuggers are a standard tool in any programming language, aiding developers in identifying a problem, isolating its source, and correcting the code. For example, in Java, the process usually allows you to set a breakpoint in the code before running the application. The execution will pause at these breakpoints to check for certain conditions, evaluate expressions, display values based on established parameters, and display other information to help you understand what’s going on in the application.
In Camel, however, the code you write doesn’t execute the application directly; it’s configuration code that instructs the framework to execute proper routing and other actions internally. And, without in-depth knowledge and experience, it is challenging to work with frameworks compared to basic programming languages such as Java. In the early days of working with Camel, our team essentially reverse-engineered the Camel framework to code the proper breakpoints and conduct “debugging.” Not fun. In other words, debugging in Camel has been virtually impossible – until now.
Why do we contribute to Apache Camel?
So, if Camel is challenging to work with, why did we choose to build our integration platform on this framework? The primary reason is that Camel is open source, and we believe in the accessibility that open source solutions enable. Open source effectively levels the playing field for financial institutions of any size. In this blog, Warren Carew, VP of Payment Solutions, speaks more to the benefits that open source solutions deliver to financial institutions within the context of building real-time payment systems.
Many of his concepts are true in the financial integration work we do with banks and credit unions. The primary benefit is its low cost of ownership due to the lack of licensing fees and reduced IT staffing costs. However, contributing to and building with open source integration solutions present several equally important advantages:
- Open source allows us to handpick from best-of-breed tools that fit the customer’s specific requirements. Proprietary systems often force you to compromise by adjusting to options that are compatible with a closed stack.
- Open source solutions tend to be more robust than their commercial counterparts due to the shared interest of the community. These systems are tested and probed for bugs and security vulnerabilities far more often than closed source systems so security issues and flaws are discovered and fixed faster.
- Lastly, we contribute to the Apache Camel project so that we can actively guide the product roadmap and evolution to better suit the needs of our customers instead of passively trying to adopt new releases to their needs.
We are evolving Apache Camel into an enterprise-grade integration platform
Many of our team members have backgrounds from MuleSoft and Microsoft and possess a deep understanding of integration technologies and best practices. After careful evaluation, it became clear that Camel was the ideal open source framework upon which we could build enterprise integration solutions for FIs.
Our approach to software development is to incrementally build out features that evolve the platform over time. This is very similar to the approach MuleSoft took. When our team members worked there, the software was still very basic but as MuleSoft added compelling features, such as Dataweave, the product evolved to be very developer-friendly. Our team is following the same approach with Camel and PortX.
We believe Camel is the premier open source integration framework. And, if you can leverage its capabilities properly, it is more powerful than expensive, industry-recognized enterprise integration solutions. We are excited to see that the Camel community continues to contribute new features that progress its potential as a go-to integration platform. One such feature is DataSonnet, the data mapping language that ModusBox contributed in December 2020. The Debugger is the latest in a line of features that we are giving back to the Camel community to evolve the platform into an enterprise-grade tool that is easier to use for the average developer.
What’s coming next
We’re hard at work building the next features that will make Camel easier to use so that PortX is the most developer-friendly integration platform available. Our architectural libraries, test frameworks, and error handling functionality will enable users to accomplish most tasks with the click of a button – all you need to do is fill in the blank.
Check out the technical preview of the debugger available with the Camel v3.15 release
The Camel framework is more complex and challenging to work with than just coding in Java, but it provides you with more powerful enterprise integration capabilities. The Debugger is an evolutionary step forward for Camel and PortX that reduces some of that complexity by making Camel as easy to debug as a programming language like Java.
Keep an eye out for the Camel v3.15 release in February 2022 which will include the debugger. If you would like to learn more about the debugger or check out the technical preview for yourself, explore the links below, leave a comment, or start a conversation with Eugene or any member of our team today.
Eugene Berman is a Senior Solutions Architect at ModusBox with 27 years of software engineering experience with integration frameworks. Before joining ModusBox, Eugene served nearly ten years as a Solution Architect and Principal Consultant for Mulesoft – one of the most widely used integration platforms globally. Today, he works alongside our product development and delivery teams to enhance the features and functionality of PortX – ModusBox’s integration platform for financial institutions built on the Apache Camel framework. He is a member of the Apache Camel tooling organization and frequently contributes code to the organization’s main branch.