anchor.diff:  = Distributed Tracing with Debezium
   
   The current pattern in application development gravitates toward microservices and microservices architecture.
  -While this approach gives the developer teams great flexibility in independent deployment and development velocity the drawback is at hand when you try to track a bug in production.
  +While this approach gives the developer teams great flexibility in terms of independent deployments and development velocity, the drawback is at hand when you try to track a bug in production.
   
  -Monolithic applications sit nicely at a single place so you can introspect the code-flows and their runtime state.
  -This is a problem with microservice architecture as a single business transaction can span across tens of services deployed in separate processes and nodes.
  +Monolithic applications sit nicely at a single place so you can introspect the code flows and the application's runtime state.
  +This is more challenging with microservice architectures, as a single business transaction can span across tens of services deployed in separate processes and compute nodes.
   
  -You can rely on traditional methods like logging where you need to collect and correlate logs at a single place so you can try to reconstruct the business transaction path.
  -This is one of the tool in the toolbox we need to use but it still can be crude and it will not provide the necessary context.
  +You can rely on traditional methods like logging where you need to collect and correlate logs at a single place, so you can try to reconstruct the business transaction path.
  +This is one of the tools in the box we can use, but it still can be crude and it will not provide all the necessary context.
   https://microservices.io/patterns/observability/distributed-tracing.html[Distributed Tracing] comes here to the rescue.
   
   == Distributed Tracing
   
  -Distributed tracing allows services to leave breadcrumbs during the execution with enough information to create an execution path of the business transaction enriched with contextual data like who, what,  and where.
  -A developer can then use it to browse through the recorded executions and check for errors or anomalies in execution that can signify either problem in deployment (services unavailability) or even a bug.
  +Distributed tracing allows services to leave breadcrumbs during the execution with enough information to create an execution path of the business transaction enriched with contextual data like "who", "what", and "where".
  +SRE teams and developers can then use it to browse through the recorded executions and check for errors or anomalies in execution that can signify either problems with deployments (services unavailabe) or even bugs.
  +
  +And this is where Debezium becomes part of the picture.
  +Data change events, as captured by Debezium from a database, and propagated via Kafka Connect and Apache Kafka to one more more downstream consumers are part of a data flow which is very valuable to have insight into.
  +How long does it take for change events to flow from source database to sink systems?
  +Where is the most time spent in the pipeline?
  +Are there any anomalies like spikes in end-to-end lags?
  +The integration of distributed tracing with Debezium can help to answer these questions.
   
   == OpenTracing
   
  -There are multiple solutions for distributed tracing but we have decided to follow and use open standard specification https://opentracing.io/[OpenTracing].
  +There are multiple solutions for distributed tracing, but as a starting poin we have decided to follow and use the https://opentracing.io/[OpenTracing] specification.
   OpenTracing is an incubating project of https://www.cncf.io/[Cloud Native Computing Foundation] which guarantees that the user will be free of any vendor lock-in by adhering to an open standard.
   
   [NOTE]
   ====
  -OpenTracing project will in future be replaced with an improved https://opentelemetry.io/[OpenTelemtry] standard.
  -Debezium will use it in the future too.
  +The OpenTracing project is in the process of being merged with OpenCensus to the improved https://opentelemetry.io/[OpenTelemetry] standard.
  +Debezium uses OpenTracing at this point for alignment reasons with other projects (e.g. Quarkus),
  +but it will use and support OpenTelemetry in the future, too.
   ====
   
   A distributed trace in OpenTracing consists of a set of spans.
  
positive.code: 
  == Conclusion
  
  In this blogpost, we have discussed what the distributed tracing is and why it is useful to use it.
  We have seen how the distributed tracing integration is done at the Debezium level to enable end-to-end tracing and tried a demo application together with Jaeger UI exploration.
  
negative.code: </div>
  ++++
  
  Filter on `order-service` as a service and click on `Find Traces`.
  Two traces should be available:
  ++++
  <div class="imageblock centered-image">
  