Opentracing Bundle Core Laravel Package

Product Decisions This Supports

• Observability Roadmap: Enables distributed tracing for microservices, APIs, or monoliths to debug latency, track requests across services, and correlate logs. Aligns with initiatives to improve SRE/DevOps tooling (e.g., Jaeger, Zipkin).
• Build vs. Buy: Avoids reinventing tracing instrumentation for Symfony/PHP, reducing dev effort. Justifies adoption if the team lacks expertise in OpenTracing or prefers vendor-neutral standards over proprietary solutions (e.g., AWS X-Ray).
• Performance Debugging: Critical for high-traffic systems (e.g., payment processing, SaaS APIs) where latency bottlenecks impact revenue. Supports A/B testing, feature flags, and async workflows by tracing user journeys.
• Compliance/Audit: Meets requirements for traceable transactions (e.g., financial services, healthcare) by logging context (e.g., user IDs, request IDs) without modifying business logic.
• Legacy Modernization: Gradual adoption for PHP/Symfony apps migrating to cloud-native architectures (e.g., Kubernetes, serverless).

When to Consider This Package

• Adopt if:

  • Your stack is Symfony 4.4+ (or PHP 7.2+) with PSR-18 HTTP clients (e.g., Symfony HTTP Client, Guzzle).
  • You need low-overhead tracing without disrupting existing code (e.g., no exceptions, async-friendly).
  • Your team uses or plans to use OpenTracing-compatible backends (e.g., Jaeger, Zipkin, Datadog).
  • You require automatic instrumentation for HTTP requests, CLI commands, and custom spans (e.g., database queries, queues).
  • You prioritize MIT-licensed, maintained (last release 2023) open-source over commercial alternatives.

• Look elsewhere if:

  • You’re using non-Symfony PHP (e.g., Laravel, Slim) or need OpenTelemetry (this package predates OTel; migration may be needed).
  • Your tracing needs are simple (e.g., basic logging) and don’t require distributed context.
  • You’re locked into a proprietary vendor (e.g., New Relic, Datadog APM) with native PHP agents.
  • Your team lacks observability maturity—start with structured logging before tracing.
  • You need real-time metrics (e.g., Prometheus) alongside traces; consider bundling with a metrics library.

How to Pitch It (Stakeholders)

For Executives: "This package lets us add ‘Google Maps for our microservices’—tracking requests as they hop between servers, APIs, and queues—without rewriting code. For example, if a payment fails, we’ll instantly see if it’s a DB timeout, third-party API delay, or our own bug. It’s like adding a ‘recording’ to every user request, but only for debugging. Used by teams at Auxmoney (25+ stars), it’s production-ready and integrates with tools like Jaeger (free) or Datadog (paid). The cost? A few dev hours to enable; the payoff? Faster incident resolution and happier customers when things go wrong."

For Engineering: *"This is a drop-in Symfony bundle that auto-instruments HTTP calls, CLI commands, and custom spans with OpenTracing. Key perks:

• Zero code changes for basic use (auto-tags root spans with Symfony context).
• PSR-18 client support: Tracing propagates automatically for Guzzle/Symfony HTTP calls.
• Non-blocking: Uses async span finishing to avoid performance hits.
• Extensible: Add custom spans for DB queries, queues, or business logic with helper methods.
• Backend-agnostic: Works with Jaeger, Zipkin, or any OpenTracing-compatible collector. Tradeoff: Not OpenTelemetry-native (but we can migrate later). Best for teams already using OpenTracing or needing a lightweight start. Let’s prototype with Jaeger first."*