Is OpenTracing for .NET still supported?

No, OpenTracing for .NET is deprecated and no longer actively maintained. The OpenTracing project has merged with OpenCensus to form OpenTelemetry, which is now the recommended standard for distributed tracing.

How do I migrate from OpenTracing to OpenTelemetry in C#?

Migrate by replacing OpenTracing API calls with OpenTelemetry equivalents, updating dependencies to OpenTelemetry .NET SDKs, and refactoring instrumentation code. OpenTelemetry offers similar concepts but with enhanced features and active support.

What tracing backends work with OpenTracing C#?

It's compatible with backends like Jaeger, Zipkin, and others that implement the OpenTracing API. However, since it's deprecated, support for newer backend versions or features may be limited or unsupported.

OpenTracing vs OpenTelemetry for .NET: which should I use?

For new projects, use OpenTelemetry as it's the modern, unified standard with active development and broader ecosystem support. OpenTracing is only suitable for maintaining existing legacy systems already integrated with it.

How to trace async methods in .NET with OpenTracing?

Use the built-in IScopeManager with AsyncLocal support. Wrap async code in using blocks with StartActive(finishSpanOnDispose: true), and spans will automatically propagate, as shown in the README's async/await example.

Can OpenTracing handle parent-child spans in microservices?

Yes, it supports automatic parent-child span relationships through IScopeManager, with manual overrides via IgnoreActiveSpan(). This enables consistent tracing across service boundaries in distributed architectures.

Open-Awesome

OpenTracing

Apache-2.0C#0.12.1

A deprecated OpenTracing API implementation for C#/.NET applications to standardize distributed tracing instrumentation.

Visit Website GitHub

515 stars71 forks0 contributors

What is OpenTracing?

OpenTracing API for .NET is a deprecated implementation of the OpenTracing specification for C# and .NET applications. It provides a standardized interface for adding distributed tracing instrumentation to applications, allowing developers to trace requests across service boundaries in microservices architectures. The library enables consistent span creation, context propagation, and tracer management regardless of the underlying tracing backend.

Target Audience

.NET developers building distributed systems or microservices who need to implement observability through distributed tracing. It's particularly relevant for teams using multiple tracing systems or planning to switch between them.

Value Proposition

Developers choose OpenTracing for .NET because it provides a vendor-neutral API that decouples instrumentation code from specific tracing implementations. This allows teams to instrument once and switch tracing backends without code changes, making it ideal for organizations with evolving observability strategies.

Overview

OpenTracing API for C# (.NET). 🛑 This library is DEPRECATED! https://github.com/opentracing/specification/issues/163

Use Cases

Best For

Instrumenting .NET microservices for distributed tracing
Standardizing tracing across multiple .NET services
Adding observability to legacy .NET applications
Creating tracing libraries or frameworks for .NET ecosystems
Migrating between different tracing systems without code changes
Implementing consistent tracing patterns across development teams

Not Ideal For

New projects prioritizing modern observability standards like OpenTelemetry
Applications requiring deep integration with a specific tracing vendor's proprietary features
Teams needing active maintenance and support for the latest .NET frameworks (e.g., .NET 8+)
Simple, single-service applications where the abstraction layer adds unnecessary complexity

Pros & Cons

Pros

Vendor-Neutral Abstraction

Provides a standardized API that allows switching between tracing backends like Jaeger or Zipkin without code changes, enabling flexibility in observability strategies as highlighted in the README.

Async-Friendly Span Management

Uses AsyncLocal in IScopeManager for automatic span propagation across async/await operations, simplifying instrumentation in asynchronous code, as demonstrated in the provided examples.

Flexible Tracer Access

Supports both dependency injection for clean architecture and GlobalTracer fallback for libraries, ensuring compatibility across various application types and frameworks.

Easy Error Tagging

Includes convenient methods like Tags.Error.Set() for marking errors on spans, streamlining debugging and monitoring in distributed systems.

Cons

Deprecated Status

The project is deprecated in favor of OpenTelemetry, meaning no new features, limited official support, and potential compatibility issues with newer .NET versions.

Implementation Overhead

Initialization is backend-specific and requires additional setup for each tracing system, adding complexity compared to directly using a vendor's SDK.

Shrinking Ecosystem

As a deprecated API, community contributions and integrations are dwindling, making it harder to find up-to-date documentation or third-party tools.

Frequently Asked Questions

Related Projects

Polly

Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. From version 6.0.1, Polly targets .NET Standard 1.1 and 2.0+.

Stars14,212

Forks1,275

Last commit4 days ago

.NET API Gateway

AspNetCore.Diagnostics.HealthChecks

Enterprise HealthChecks for ASP.NET Core Diagnostics Package

Stars4,369

Forks865

Last commit1 month ago

Foundatio

Pluggable foundation blocks for building distributed apps.

Stars2,095

Forks251

Last commit22 hours ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub