WSO2 is now Choreo LabsLearn more

Trusted AI Governance
Build

Create agents and AI apps with the tools and languages your teams already use.

Connect

Link agents securely to your APIs, data, models and business systems.

Run

Deploy, observe and operate agents and AI apps reliably at any scale.

Govern

Control identity, access, cost and policy for every agent in production.

Agent Management

Developer Platform

  • API Management Cloud

    Design, secure and publish APIs with governance and analytics built in.

    Sign Up Now
  • Integration Cloud

    Connect apps, data and AI agents with low-code and pro-code integration.

    Sign Up Now
  • Identity & Access Management Cloud

    Secure sign-in and access for customers, partners, workforce and agents.

    Sign Up Now
  • Agent Management Cloud

    Build, run and govern AI agents with full visibility and control.

    Sign Up Now
  • Developer Platform Cloud

    Ship cloud-native apps faster on an internal developer platform.

    Sign Up Now

Self-Hosted

Full control over your stack. Deploy directly to your own servers, bare metal, cloud, or Kubernetes environment. Your data never leaves your perimeter.

Product Downloads
Choreo Labs
AI Governance
Platform
Solutions
Resources
Blog

Introducing observability for polyglot applications

Photo by Philippe Bout on Unsplash

Introduction

With the recently introduced Build and Deploy Your Dockerfile feature, users can now create awesome digital experiences quickly, easily, and securely using any programming language they prefer. Once they develop their application and containerize it, Choreo will take care of the rest by building and deploying it to Kubernetes in minutes.

Irrespective of the language used to write applications, the ability to observe them is vital. While it’s possible to instrument applications and add observability capabilities, this takes time and requires domain expertise. With Choreo, users don’t need to set up language-specific agents or expose metrics using additional libraries, and they can leverage the platform’s observability capabilities without hassle.

Until now, Choreo provided observability only for components written using Ballerina. We’re happy to announce that it now provides the ability to observe components written in any language.

Observing Polyglot Components

To view the information that is available for observing polyglot components, you first need to create a component with the Dockerfile build present and deploy it in Choreo. Refer to Figures 1 and 2 to see how this can be done.

Figure 1: Menu to create a REST API

Figure 2: Deploy view

After you send requests to the component, Choreo will show you observability data. You’ll be able to use several metrics to observe the component as shown in Figure 3. The throughput graph shows the processing rate of requests, while the latency graph shows the mean latency as well as 50th, 90th, and the 99th latency percentiles.

Figure 3: Choreo observability view: application performance and logs

The diagnostics view (as shown in Figure 4) makes it possible to correlate all metrics: error rate, throughput, latency, CPU usage, and memory usage. This correlation is useful for debugging issues in components. For example, a very high CPU usage could be the reason why the component is having a high request latency.

Figure 4: Diagnostic view of Choreo observability

In addition, Choreo also shows you logs from your containers as shown in Figure 5.

Figure 5: Logs view in Choreo observability

How Does Choreo Do That?

Since Choreo doesn’t restrict the programming languages you can use, it would mean the platform would have to instrument a variety of them. This would have been complex. To solve this problem, Choreo uses extended Berkeley Packet Filter (eBPF) [1] to collect data about how your components are performing. eBPF makes it possible to run sandboxed programs at the Linux Kernel level without having to modify the Kernel or load additional Kernel modules. This makes it possible to use eBPF for many interesting use-cases like observability. It is this eBPF-based data collection capability that allows Choreo to gather observability data without language specific instrumentation.

Choreo uses Pixie to collect data on non-Ballerina components. Pixie is an open-source Kubernetes observability platform that uses eBPF along with other machine-level metrics to provide observability.

Choreo uses these metrics along with logs to provide a feature-rich observability view that users can use to gain valuable insights about how their components are running in Choreo.

What’s Next?

In Choreo, when you work with components, you can use the component-level observability view as explained above to gain insights about a single component. A Choreo project is typically made up of several related components. Therefore, it is equally important to observe how different components interact. To make this possible, we will soon unveil new features to make project-level observability possible.

Conclusion

In addition to providing deep observability for Ballerina components, we’ve expanded Choreo’s observability capabilities to non-Ballerina components as well. Developers now have the freedom to create components using their language of choice while being able to observe them without having to do any manual instrumentation.

Visit Choreo to sign up for an account and see how you can create awesome digital experiences quickly, easily, and securely.

References

[1] - https://ebpf.io/