Distributed Tracing in .NET using OpenTelemetry

Distributed Tracing has been around for a while, but was always quite niche, reserved for the Netflix and Amazon's of the world. With your company likely looking more at Microservices as a path forward to scale and modernisation, you will almost certainly start to think about debugging and monitoring this in production.

We'll walk through what distributed tracing is, how it relates to Observability (o11y), and then run through some examples of how to get started with it in your .NETapplications.

Finally, we'll demo how to visualise the data, from .NET Aspire, to Jaegar.

This is NOT a vendor talk, however, some of the demos will use the Honeycomb backend to visual the output. The focus is on the tooling and usecases.

Practical OpenTelemetry in .NET 8

You've likely heard about OpenTelemetry and are either starting to use it, or thinking about using it in your applications as you should! But how do you use it effectively, how should you set things up, what spans or activities should you create, how should you name them?

In this talk we'll cover:
* Codeless instrumentation
* Getting automatic spans from popular libraries
* What application context is important in your observability
* Different setup techniques
* Using OpenTelemetry in messaging systems like Azure ServiceBus and Kafka
* How to export your telemetry signals to an Free OpenSource backend
* How K8s can make observability simpler

This will be a talk about best practices, tips and tricks for getting the most out of OpenTelemetry.

Practical OpenTelemetry in Javascript/Typescript

You've likely heard about OpenTelemetry and are either starting to use it, or thinking about using it in your applications as you should! But how do you use it effectively, how should you set things up, what spans or activities should you create, how should you name them?

In this talk we'll cover:
* Codeless instrumentation
* Getting automatic spans from popular libraries
* What application context is important in your observability
* Different setup techniques
* Using OpenTelemetry in messaging systems like Azure ServiceBus and SQS/SNS
* How to export your telemetry signals to a backends
* How K8s can make observability simpler

This will be a talk about best practices, tips and tricks for getting the most out of OpenTelemetry.

What is this OpenTelemetry thing?

OpenTelemetry is the second most popular project from the CNCF, after Kubernetes, but what is it?

In this talk, we'll cover where OpenTelemetry comes from, what problem it's solving, and then into the components that make up OpenTelemetry (from the protocol to the SDKs).

We'll walk through an example around how to implement it for the core signals (Logs, Metrics and Tracing), and show how propagation between services (both synchronous and Asynchronous works).

You'll come away from this talk knowing when it's useful to use OpenTelemetry, what words to use when you're talking about it, and also a picture of what value it adds.

Building for Production in a Microservices environment

Production is the only environment that truly matters to your organisation, which is why that should be the focus of what we build and how we build it. If we're working in a Microservices world, this is actually something we can do quite effectively by modelling our external connections properly.

In this session, we'll talk about the different feedback loops we get in software and also how we can model an outside-in testing approach for faster feedback and greater confidence.

I'll talk about this from the perspective a system I built over 2 years with almost not class or method level tests.

What's new in OpenTelemetry (2025 edition)?

OpenTelemetry has been moving fast over the last few years, from new signals like Continuous Profiling and RUM, to enhancements to the SDKs and the Semantic Conventions, but why should you care?

In this talk we'll cover all the changes over the last 12 months, why they exist, what usecases they enable, and how they'll help you be a better developer. We'll then go to the future and talk about what's coming over the next 12 months.

You'll come away with an understanding of what you might have missed, but also an idea of what to look out for as you're building out your systems.

Architecting for Observability

Observability is more than just installing just an agent on a machine and sending it to a backend so you can visualise it. As our systems have evolved to be more bespoke, nuanced, and less monolithic so have the needs we have for debugging how they're running in our production environments.

In this talk we'll cover some of the techniques you'll need to build robust telemetry pipelines that allow your backends to provide the maximum value.

We'll cover:
* Deployment patterns for gathering telemetry
* OpenTelemetry Collector usecases
* Sampling, head/tail/dynamic/adaptive and the benefits/drawbacks
* Zero-code agents and curated/bespoke telemetry
* Kubernetes, Azure, AWS and the different patterns for each.

You should come away from this session with a wider understanding of how you can architect your platform and applications to make better use of telemetry in Post-APM world.

Practical OpenTelemetry for Modern Applications (Workshop)

Observability is more than a buzzword, it's about a culture of reliability, but how do you get there? Well you need to start with the data, the telemetry signals. Gathering them, curating them, and securely sending them to a backend for visualisation.

In this workshop we'll cover how to implement OpenTelemetry in modern application stacks like .NET, Javascript and Python on the backend. Then we'll dive into how to forward that data into a backend to visualise the data we have.

This is a hands-on workshop where you'll be writing code to implement and curate a telemetry experience for an example application. We'll cover:

* Zero-code instrumentation
* Coded and Automatic instrumentation
* Collector pipelines
* Sampling techniques to manage load and cost
* Generating metrics
* Analysing raw telemetry data

Everything in the workshop will be using free, OpenSource software, so at the end of the workshop you'll be able to implement all your learnings in your company's applications.

For the workshop you'll need:

A Laptop (that can connect to the conference wifi)
Docker installed (or something capable of running Docker Compose)
An IDE you're familiar with for your language*
A text editor (We recommend VSCode)

*Although any language can be used, the examples will be in JS/TS, .NET and Python, limited help can be given for other languages but please reach out ahead of time if you're interested as we may be able to accommodate you.