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.

OpenTelemetry for .NET Developers

OpenTelemetry is the biggest project to come out for the Cloud Native Computing Foundation since Kubernetes. It's now the de facto standard for extracting telemetry from your applications. Microsoft have adopted it, and so should you, but how?

In this talk we'll cover what the principal of Observability is, and how OpenTelemetry can help achieve it. We'll also cover best practices for using OpenTelemetry in your .NET applications and you can use the data to understand your production systems in both Open Source and SaaS solutions.

You'll come out of this talk with practical knowledge of how take your OpenTelemetry usage to the next level or how to get started right now.

Hands On OpenTelemetry (2 Day Workshop)

You've heard the new buzzwords of "Observability", "OpenTelemetry", "Tracing", and all the others, but not sure how to practically use them in your applications to help debug issues? This is the workshop you need.

In this workshop you'll get your hands on using OpenTelemetry in a realistic microservice system. You'll be adding the libraries in the applications, Using the "Agents" to instrument applications without code changes, and touching various languages (whatever you're comfortable with) and more.

You'll come out of this workshop understanding:
* What Observability is and is not
* Where OpenTelemetry fits in
* How to implement OpenTelemetry in your language of choice (and possibly some others)
* Auto-instrumentation of OpenTelemetry (where you can't change the code)
* What the OpenTelemetry Collector is, when to use it, and how to use it
* Finally, we'll cover Querying and using the data we see to find some hidden patterns.

Building Operable Software with TDD (but not the way you think)

Building operable software is becoming more important with the adoption of Microservice based systems becoming more common. Developers are increasingly relying on building long-running "integration" tests in deployed environments because it's the only way to gain confidence to deploy their applications. There is a better way, which is to focus on "outside-in" testing that focuses on testing the boundaries of your service.

In this talk, we'll go through some of the pitfalls of relying on unit testing to give you confidence in an application. We'll then go through how you can use TDD as a workflow to build tests in a "Contract First" way and how much more flexible your testing becomes. We'll talk about the benefits over Unit testing focus, and how it can aid in understanding service boundaries. Finally, we'll show you can correlate all this up with Tracing tools like Honeycomb to see the performance of your tests and how internal code interacts.

This talk will be focusing on the WebApplicationFactory in .NET to provide the scaffold, and Honeycomb to provide the visibility, however, the concepts will likely apply to other languages.

OpenTelemetry for Developers (1 Day Workshop)

You've heard the new buzzwords of "Observability", "OpenTelemetry", "Tracing", "Logging", "Metrics", and all the others, but still not sure how to practically use them in your applications to help debug issues? This is the workshop you need.

In this workshop you'll get your hands on experience using OpenTelemetry in an application you create. You'll be adding the libraries in the applications to get some out of the box information, along with adding different types of manual instrumentation to get domain specific insights.

You'll come out of this workshop understanding:
* What Observability is and is not
* Where OpenTelemetry fits in
* How to implement OpenTelemetry in your language of choice
* What the OpenTelemetry Collector is, when to use it, and how to use it
* What commercial Observability Products bring to the table

All of this will be done with OpenSource tools.

This is a hands on session and the attendees will need access to a laptop with their desired programming environment already setup.

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).

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

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.