Modern applications are increasingly becoming more of a distributed computing problem. With the availability of feature rich cloud services, our solutions are increasingly relying on these in implementing functionality. Also, the application itself is adopting more of a disaggregated architecture in favour of extensibility, scalability, re-usability, and deployment flexibility. This is how microservices architectures are becoming popular every day. But there is no free lunch; with the benefits, there are new challenges that are introduced. Compared to monoliths, with microservices we need to handle the complexities that come with networked architectures, such as communication latency, unreliable connections, protocols, data formats, and transactions. So, while we come up with many new techniques to tackle these problems, it is vital for us to have a proper observability functionality to verify the behaviour. The Ballerina programming, which is designed from ground-up to work with networked applications, takes in a unique approach by having built-in observability functionality in language constructs. It exploits the language awareness for network operations, such as service types, remote function invocations, communication resiliency mechanisms, to automatically observe the operations done by the users. Basically, the Ballerina platform takes care of the majority observability situations automatically, so the developer can only focus on the core business logic, and not sprinkle your code with lots of observability code. In this session, we will look at these features on how this built-in functionality will be used for metrics generation and distributed tracing using the Ballerina platform.

1. Automatic Microservices Observability with Ballerina
Anjana Fernando | Director - Developer Relations | WSO2 Inc.
@lafernando

2. Agenda
● Hello, World!
● Introduction to Ballerina Services
● Integration Scenario
⦿ HTTP Service: Geolocation + Geocoding
⦿ Observability
⦾ Metrics
⦾ Distributed Tracing
⦿ Communication Channels
⦾ HTTP
⦾ Databases
⦾ WebSockets
⦾ gRPC
⦾ RabbitMQ
● Observability in the Cloud

3. Hello, World!
caller greeting
GET
Hello!

4. Services
Service name: base path Listener object Resource return type
Resource accessor Resource name

5. Integration Scenario: Geolocation + Geocoding

6. Distributed Tracing: Jaeger/Zipkin

7. Metrics: Prometheus + Grafana

8. Observability in the Cloud: WSO2 Choreo (https://choreo.dev)
1 Simultaneous code & low-code
● Low code ← → Source Code
● Enhanced productivity and collaboration
● For developers of all skill levels
3 An all inclusive cloud native engineering
solution in one platform
● Create integrations, services, and APIs
● Manage APIs
● Deploy services and APIs
2 Rapid deployment
● Eliminate time spent on platform building
● Focus on creating applications that make your
business better
● Code→Test→Deploy→Observe
4 Deep Observability
● View observability data and troubleshoot
issues.
● AI-based anomaly alerts call your attention
when required and help isolate the problem.
5 AI assisted development
● Learning from historical activities and
performance behaviours
● Receive feedback as you code—while
pushing the boundaries of AI.
6 Lock-in free low-code
● Your low-code is just source code.
● Clone the repository, build it using freely
available open source tools, and run it wherever
you want.
● Your (low-)code is always yours to take and run.

9. Resources
● Demo Source Code
⦿ https://github.com/lafernando/samples/tree/master/ballerina/observability
● Ballerina Examples/Guides
⦿ https://ballerina.io/learn/
⦿ https://ballerina.io/learn/by-example/
● WSO2 Choreo
⦿ Beta access available: https://choreo.dev
● Community
⦿ Stack Overflow - #ballerina tag
⦿ Slack - https://ballerina.io/community/slack/