Index
A
- Ad-hoc analysis / Ad hoc analysis
- Ad-hoc sampling / Ad-hoc or debug sampling
- adaptive sampling / Guaranteed-throughput probabilistic sampling
- about / Adaptive sampling
- local adaptive sampling / Local adaptive sampling
- global adaptive sampling / Global adaptive sampling
- implications / Implications of adaptive sampling
- extensions / Extensions
- agent-based instrumentation / Metadata propagation
- agent-based instrumentation style / Styles of instrumentation
- all-or-nothing approach / Where to start
- Ambassador pattern
- about / Service meshes
- application performance
- aspects, investigating / Performance analysis
- application performance monitoring (APM) / Tail-based consistent sampling
- application performation analysis
- critical path analysis / Critical path analysis
- trace patterns, recognizing / Recognizing trace patterns
- exemplars / Exemplars
- latency histograms / Latency histograms
- architectural problems
- detecting / Detecting architectural problems
- architecture modes / Architecture and deployment modes
- aspect-oriented programming (AOP) / My experience with tracing
- aspects, application performance
- availability / Performance analysis
- correctness / Performance analysis
- speed / Performance analysis
- asynchronous code
- instrumenting / Instrumenting asynchronous code
- auto-instrumentation
- about / Exercise 6 – auto-instrumentation
- in Java / Auto-instrumentation in Java
- in Python / Auto-instrumentation in Python
B
- backend
- tracing / Why host your own?
- customizations / Customizations and integrations
- integrations / Customizations and integrations
- bandwidth cost / Bandwidth cost
- data, tracing / Own the data
- baggage / Identifying sources of latency, Distributed tracing with Istio
- using / Exercise 5 – using baggage
- using, in Go / Exercise 5 – using baggage
- using, in Java / Exercise 5 – using baggage, Exercise summary
- Baggage Definition Language (BDL) / Brown Tracing Plane
- barrier to adoption
- reducing / Reduce the barrier to adoption
- Billing component / Anatomy of tracing deployment and interoperability
- black-box inference
- about / Black-box inference
- brown tracing plane
- about / Brown Tracing Plane
- Baggage Layer / Brown Tracing Plane
- Atom Layer / Brown Tracing Plane
- Transit Layer / Brown Tracing Plane
- brush select / Observing trends
- building applications
- culture, modifying / Building the culture
- value / Explaining the value
- integrating, with developer workflows / Integrating with developer workflows
C
- causality
- preserving / Preserving causality
- inter-request causality / Inter-request causality
- causality references / Distributed tracing
- Chaos Engineering / Chaos engineering
- clock skew adjustment
- about / Clock skew adjustment
- Cloud Native Computing Foundation (CNCF)
- reference / OpenTracing
- Cloud Native Computing Foundation (CNCF) / Microservices and cloud-native applications
- components, data mining pipeline
- about / Components of a data mining pipeline
- backend, tracing / Components of a data mining pipeline, Tracing backend
- completion trigger, tracing / Components of a data mining pipeline, Trace completion trigger
- extractor, features / Components of a data mining pipeline
- aggregator / Components of a data mining pipeline, Aggregator
- storage / Components of a data mining pipeline
- feature extractor / Feature extractor
- context
- passing / Exercise 3 – tracing functions and passing context
- passing, between processes / Step 2 – pass the context between processes
- context-sensitive sampling / Context-sensitive sampling
- Context type
- reference / In-process context propagation in Go
- contextualized logs
- handling / Contextualized logs
- about / Contextualized logs
- contextual metadata / Distributed tracing
- continuation local storage (CLS) / Step 3 – propagate the in-process context
- control flow / Client
- control plane
- about / Service meshes
- components / Service meshes
- Conway's law / Why is it hard to deploy tracing instrumentation?
- correction signal / Theory
- counter / Architecture
- critical path driven development (CPDD) / Critical path analysis
- Cross-Cutting Layer / Brown Tracing Plane
- curl
- reference / Query tools (curl or wget)
D
- data analysis
- classes / Ad hoc analysis
- data centers (DCs) / Bandwidth cost
- data mining pipeline
- components / Components of a data mining pipeline
- downsides / Trace completion trigger
- data plane
- about / Service meshes
- data tracing, via Istio
- prerequisites / Prerequisites
- source code / Project source code
- Java development environment / Java development environment
- Kubernetes, installing / Kubernetes
- Istio, installing / Istio
- Hello application, implementing / The Hello application
- debug sampling / Ad-hoc or debug sampling
- deployment modes / Architecture and deployment modes
- desired process value / Theory
- detecting degradation / Performance analysis
- Directed Acyclic Graph / The architecture
- directed acyclic graph (DAG) / Feature extraction
- distributed context
- using / Distributed context and routing
- distributed context propagation / Metadata propagation
- distributed context propagation (DCP) / Brown Tracing Plane
- distributed stack traces
- about / Span model
- distributed tracing
- about / Distributed tracing, My experience with tracing
- anatomy / Anatomy of distributed tracing
- with Istio / Distributed tracing with Istio
- distributed tracing / Tracing as a knowledge base
- Docker
- reference / Kafka, Zookeeper, Redis, and Jaeger
- server, executing / Running the servers in Docker
- docker-compose tool
- reference / Kafka, Zookeeper, Redis, and Jaeger
- Docker images
- reference / Running from Docker images
- HotROD demo application, executing from / Running from Docker images
- domain-specific language (DSL) / Context-sensitive sampling, Ad hoc analysis
- dtrace / What is observability?
- dynamic metadata
- using / Preserving causality
E
- effective sampling rate / Local adaptive sampling
- Elasticsearch / Feature extraction exercise
- Elasticsearch-Logstash-Kibana (ELK) / Step 3 – annotate the span
- emerging standards / Bet on emerging standards
- Enterprise Service Bus (ESB) / Microservices and cloud-native applications, Service meshes
- error / Theory
- event model
- about / Event model
- execution identifier / Metadata propagation
- exemplars / Exemplars
- exporters / OpenCensus
- extract trace point / Anatomy of distributed tracing
F
- Failure Injection Testing (FIT) / Chaos engineering
- feature extraction
- federating transactions / W3C "Data Interchange Format"
- fixed-width dynamic metadata
- using / Preserving causality
- Flask framework
- reference / Hello application in Python
- Fluentd / Microservices and cloud-native applications
- functions
G
- global adaptive sampling
- about / Global adaptive sampling
- goals / Goals
- theory / Theory
- architecture / Architecture, Calculating sampling probability
- sampling probability, calculating / Calculating sampling probability
- Go
- Hello application, executing / Hello application in Go
- tracer, creating / Create a tracer in Go
- span, starting / Start a span in Go
- span, annotating / Annotate the span in Go
- multiple spans, combining into single trace / Combine multiple spans into a single trace in Go
- in-process context propagation / In-process context propagation in Go
- microservices / Microservices in Go
- context, passing between processes / Passing context between processes in Go
- standard tags / Standard tags in Go
- baggage, using / Exercise 5 – using baggage
- open source instrumentation / Open source instrumentation in Go
- reference / Running from source
- Go development environment
- installation link / Go development environment
- Go language
- reference / Go language development environment
- HotROD demo application, implementing / Go language development environment
- guaranteed-throughput probabilistic
- sampling / Guaranteed-throughput probabilistic sampling
- guaranteed-throughput sampler / Guaranteed-throughput probabilistic sampling
H
- happens-before relation / Preserving causality
- head-based consistent sampling
- about / Head-based consistent sampling
- probabilistic sampling / Probabilistic sampling
- rate limiting sampling / Rate limiting sampling
- gGuaranteed-throughput probabilistic sampling / Guaranteed-throughput probabilistic sampling
- adaptive sampling / Adaptive sampling
- context-sensitive sampling / Context-sensitive sampling
- Ad-hoc sampling / Ad-hoc or debug sampling
- debug sampling / Ad-hoc or debug sampling
- oversampling / How to deal with oversampling
- Hello application
- creating / Exercise 1 – the Hello application
- executing, in Go / Hello application in Go
- executing, in Java / Hello application in Java
- executing, in Python / Hello application in Python, Exercise summary
- about / The Hello application
- jaeger client / The Hello application
- prom client / The Hello application
- architecture / The Hello application
- historical analysis / Historical analysis
- HotROD demo application
- prerequisites / Prerequisites
- executing, from pre-packaged binaries / Running from prepackaged binaries
- executing, from Docker images / Running from Docker images
- executing, from source code / Running from the source code
- implementing, in Go language / Go language development environment
- Jaeger source code / Jaeger source code
- about / Meet the HotROD
- architecture / The architecture
- data flow / The data flow
- sources of latency, identifying / Identifying sources of latency
- hypothetical e-commerce website
- architectural diagram / The idea
I
- IDE plugin / Developing in production
- in-process context propagation
- in Python / In-process context propagation in Python
- in Java / In-process context propagation in Java
- in Go / In-process context propagation in Go
- in-process propagation / Metadata propagation
- incremental tracing rollout / Where to start
- indexer component / Streaming architecture
- individual functions
- tracing / Step 1 – trace individual functions
- tracing, in Go / Trace individual functions in Go
- tracing, in Java / Trace individual functions in Java
- tracing, in Python / Trace individual functions in Python
- ingester component / Streaming architecture
- Injection Testing (FIT) / Chaos engineering
- inject trace point / Anatomy of distributed tracing
- instrumentation
- styles / Styles of instrumentation
- instrumentation API
- about / Styles of instrumentation
- requirements / Styles of instrumentation
- integrations, with logs
- about / Integration with logs
- structured logging / Structured logging
- logs, correlating with trace context / Correlating logs with trace context
- context-aware logging APIs / Context-aware logging APIs
- logs, capturing in tracing system / Capturing logs in the tracing system
- logging backends / Do we need separate logging and tracing backends?
- tracing backends / Do we need separate logging and tracing backends?
- integrations, with metrics
- about / Integration with metrics
- standard metrics, via tracing instrumentation / Standard metrics via tracing instrumentation
- context, adding / Adding context to metrics
- context-aware metrics APIs / Context-aware metrics APIs
- inter-process propagation / Metadata propagation
- inter-request causality / Inter-request causality
- Inventory module / Anatomy of tracing deployment and interoperability
- Istio
- installing / Istio
- reference / Istio
- used, for distributed tracing / Distributed tracing with Istio
- service graph, generating / Using Istio to generate a service graph
J
- Jaeger / Microservices and cloud-native applications, Jaeger
- starting / Start Jaeger
- architecture / Basic architecture: agent + collector + query service
- client / Client
- agent / Agent
- collector / Collector
- query service / Query service and UI
- UI / Query service and UI
- data mining jobs / Data mining jobs
- monitoring / Monitoring and troubleshooting
- troubleshooting / Monitoring and troubleshooting
- jaeger-ingester / Feature extraction exercise
- Java
- Hello application, executing / Hello application in Java
- tracer, creating / Create a tracer in Java
- span, starting / Start a span in Java
- span, annotating / Annotate the span in Java
- multiple spans, combining into single trace / Combine multiple spans into a single trace in Java
- in-process context propagation / In-process context propagation in Java
- microservices / Microservices in Java
- context, passing between processes / Passing context between processes in Java
- standard tags / Standard tags in Java
- auto-instrumentation / Auto-instrumentation in Java
K
- Kafka
- support for OpenTracing / Kafka instrumentation
- messages, producing / Producing messages
- messages, consuming / Consuming messages
- Kibana / The Hello application
- index pattern, declaring / Declaring index pattern in Kibana
- index pattern, defining in / Define an index pattern in Kibana
- Kibana UI / Feature extraction exercise
- Kubernetes
- installing / Kubernetes
- reference / Kubernetes
L
- latency histograms / Latency histograms
- leaky bucket algorithm / Rate limiting sampling
- lib module, Tracing Talk chat application
- about / The lib module
- AppId class / AppId
- Message class / Message
- KafkaConfig class / KafkaConfig and KafkaService
- KafkaService class / KafkaConfig and KafkaService
- RedisConfig class / RedisConfig and RedisService
- RedisService class / RedisConfig and RedisService
- GiphyService class / GiphyService
- Lineage-driven Fault Injection (LDFI) / Chaos engineering
- local adaptive sampling / Local adaptive sampling
- logs
- versus span tags / Span tags versus logs
- long-term profiling / Long-term profiling
M
- Mapped Diagnostic Context (MDC) / Structured logging
- metadata propagation
- about / Metadata propagation
- in-process propagation / Metadata propagation
- inter-process propagation / Metadata propagation
- disadvantage / Metadata propagation
- metrics / Three pillars of observability
- Micrometer
- reference / Context-aware metrics APIs
- microservices
- and cloud-native applications / Microservices and cloud-native applications
- characteristics / Microservices and cloud-native applications
- observability challenge / The observability challenge of microservices
- design, challenges / The observability challenge of microservices
- in Go / Microservices in Go
- in Java / Microservices in Java
- in Python / Microservices in Python
- microservices simulator
- reference / Feature extraction exercise
- about / Microservices simulator
- Docker image, running as / Running as a Docker image
- running, from source / Running from source
- verifying / Verify
- minikube / Kubernetes
- modeled trace
- about / Span model
- monkey-patching / Styles of instrumentation
- monorepo (monolithic repository / Monorepos
- multi-server spans
- about / Span model
- multi-tenancy
- about / Multi-tenancy
- cost accounting / Cost accounting
- complete isolation / Complete isolation
- granular access control / Granular access controls
- multiple DCs
- executing / Running in multiple DCs
- cross-zone federation / Cross-zone federation
- multiple spans
- combining, into single trace / Step 2 – combine multiple spans into a single trace
- MySQL database
- download link / MySQL database
O
- object-relational mapping (ORM) / Avoid sequential execution or "staircase"
- observability / What is observability?
- pillars / Three pillars of observability
- metrics / Three pillars of observability
- logging frameworks / Three pillars of observability
- sampling / Three pillars of observability
- distributed tracing instrumentation / Three pillars of observability
- OpenCensus / OpenCensus
- OpenJDK
- download link / Java development environment
- OpenTracing / Microservices and cloud-native applications, OpenTracing
- reference / Auto-instrumentation in Java
- Tracing Talk chat application, instrumenting with / Instrumenting with OpenTracing
- Spring instrumentation / Spring instrumentation
- tracer resolver / Tracer resolver
- Redis instrumentation / Redis instrumentation
- Kafka instrumentation / Kafka instrumentation
- OpenTracing-recommended tags
- applying / Step 3 – apply OpenTracing-recommended tags
- OpenTracing Industrial Advisory Board (OTIAB) / OpenTracing
- OpenTracing project / OpenTracing
- community contributions, reference / Exercise 7 – extra credit
- OpenTracing Specification Council (OTSC) / OpenTracing
- OpenZipkin / Zipkin and OpenZipkin
- origin zone
- capturing / Capturing origin zone
- OSS (open-source software) framework / Know your audience
P
- parent ID
- about / Span model
- parent span
- about / Span model
- partial sampling / Partial sampling
- path-aware graphs / Deep, path-aware service graphs
- pip tool
- reference / Python development environment
- Pivot Tracing / Pivot tracing
- post-collection down-sampling / Post-collection down-sampling
- pre-packaged binaries
- HotROD demo application, executing from / Running from prepackaged binaries
- reference / Running from prepackaged binaries
- prerequisites
- about / Prerequisites
- project source code / Project source code
- Go development environment / Go development environment
- Java development environment / Java development environment
- Python development environment / Python development environment
- MySQL database / MySQL database
- query tools (curl or wget) / Query tools (curl or wget)
- tracing backend (Jaeger) / Tracing backend (Jaeger)
- prerequisites, microservices simulator
- about / Prerequisites
- project source code / Project source code
- servers, running in Docker / Running the servers in Docker
- index mapping, defining in Elasticsearch / Defining index mapping in Elasticsearch
- Java development environment / Java development environment
- index pattern, defining in Kibana / Define an index pattern in Kibana
- prerequisites, tracing integration
- project source code / Prerequisites, Project source code
- Java development environment / Java development environment
- servers, executing in Docker / Running the servers in Docker
- index pattern, declaring in Kibana / Declaring index pattern in Kibana
- clients, executing / Running the clients
- probabilistic sampling / Probabilistic sampling
- process context
- propagating / Step 3 – propagate the in-process context
- process value / Theory
- Prometheus / Microservices and cloud-native applications, The Hello application
- proportional-integral-derivative (PID) / Theory
- Python
- Hello application, executing / Hello application in Python
- tracer, creating / Create a tracer in Python
- span, starting / Start a span in Python
- span, annotating / Annotate the span in Python, Exercise summary
- multiple spans, combining into single trace / Combine multiple spans into a single trace in Python
- in-process context propagation / In-process context propagation in Python
- microservices / Microservices in Python
- context, passing between processes / Passing context between processes in Python
- standard tags / Standard tags in Python
- baggage, using / Exercise 5 – using baggage
- auto-instrumentation / Auto-instrumentation in Python
- Python
- reference / Python development environment
R
- rate limiter / Rate limiting sampling
- rate limiting
- sampling / Rate limiting sampling
- React
- reference / The Tracing Talk chat application
- RED (Rate, Error, Duration) / Standard metrics via tracing instrumentation
- RED (Rate, Error, Duration) method / Observability via a service mesh
- Redis
- support for OpenTracing / Redis instrumentation
- regions / Running in multiple DCs
- remotesrv application
- about / Event model
- request correlation, distributed tracing
- about / Request correlation
- black-box inference / Black-box inference
- schema-based / Schema-based
- metadata propagation / Metadata propagation
- reservoir sampling / Rate limiting sampling
- resiliency
- about / Resiliency
- over-sampling / Over-sampling
- debug traces / Debug traces
- DC failover / Traffic spikes due to DC failover
- perpetual traces / Perpetual traces
- long traces / Very long traces
- resource usage attribution
- about / Resource usage attribution
- RFC (request for comment) process / OpenTracing
- RFC (Request for Comments) / Tracing as a knowledge base
- Rides on Demand (ROD) / Meet the HotROD
- routing / Distributed context and routing
- RPC requests
- tracing / Exercise 4 – tracing RPC requests
- monolith, breaking up / Step 1 – break up the monolith
S
- sampling / Sampling
- sampling per service / Local adaptive sampling
- schema-based technique
- about / Schema-based
- security / Security
- service-oriented architecture (SOA) / My experience with tracing
- service and endpoint / Local adaptive sampling
- service graph
- generating, with Istio / Using Istio to generate a service graph
- service graphs
- about / Service graphs
- limitations / Service graphs
- path-aware graphs / Deep, path-aware service graphs
- service level objectives (SLOs) / Step 2 – start a span
- service mesh
- about / Service meshes
- data plane / Service meshes
- control plane / Service meshes
- observability / Observability via a service mesh
- Service Mesh Control Plane / Developing in production
- service mesh Istio / Debugging in production
- service name / Step 1 – create a tracer instance
- shared spans
- about / Span model
- shrimp / Deep, path-aware service graphs
- sidecar pattern
- about / Service meshes
- advantages / Service meshes
- Simian Army / Chaos engineering
- single-host span model
- about / Span model
- Site Reliability Engineering (SRE) / Exemplars
- site reliability engineers (SREs) / Calculating sampling probability
- SkyWalking / SkyWalking
- SLF4J API / Structured logging
- Software as a Service (SaaS) / Complete isolation
- SOSP 2015 (Symposium on Operating Systems Principles / Pivot tracing
- source code
- HotROD demo application, executing from / Running from the source code
- source code, Jaeger
- reference / Jaeger source code
- span
- starting / Step 2 – start a span
- starting, in Go / Start a span in Go
- starting, in Java / Start a span in Java
- starting, in Python / Start a span in Python
- annotating / Step 3 – annotate the span
- annotating, in Go / Annotate the span in Go
- annotating, in Java / Annotate the span in Java
- annotating, in Python / Annotate the span in Python
- span context / OpenTracing
- Span Count job
- about / The Span Count job
- completion trigger, tracing / Trace completion trigger, Feature extractor
- span model
- about / Span model
- spans
- about / Span model
- span tags
- versus logs / Span tags versus logs
- Spring
- support for OpenTracing / Spring instrumentation
- Spring Boot framework
- reference / Hello application in Java
- Squash debugger / Debugging in production
- Stackdriver / X-Ray, Stackdriver, and more
- standard projects, tracing systems
- about / Standards projects
- W3C Trace Context / W3C Trace Context
- W3C / W3C "Data Interchange Format"
- OpenCensus / OpenCensus
- OpenTracing / OpenTracing
- standard tags / Step 3 – apply OpenTracing-recommended tags
- span.kind / Step 3 – apply OpenTracing-recommended tags
- http.method / Step 3 – apply OpenTracing-recommended tags
- in Go / Standard tags in Go
- in Java / Standard tags in Java
- in Python / Standard tags in Python
- static metadata
- using / Preserving causality
- streaming architecture / Streaming architecture
T
- tail-based consistent sampling / Tail-based consistent sampling
- downsides / Tail-based consistent sampling
- techniques, for reducing barrier to adoption
- standard frameworks / Standard frameworks
- in-house adapter libraries / In-house adapter libraries
- tracing enabled by default / Tracing enabled by default
- monorepos / Monorepos
- existing infrastructure, integrating with / Integration with existing infrastructure
- Telepresence / Developing in production
- throttling / Throttling
- trace
- about / The idea
- creating / Exercise 2 – the first trace
- instance, creating / Step 1 – create a tracer instance
- creating, in Go / Create a tracer in Go
- trace analysis
- about / Trace analysis
- trace context
- logs, correlating / Correlating logs with trace context
- trace features
- examples / Feature extraction
- trace model
- about / Trace models
- event model / Event model
- span model / Span model
- trace patterns
- recognizing / Recognizing trace patterns
- error markers, checking / Look for error markers
- longest span on critical path, checking / Look for the longest span on the critical path
- missing details, checking / Look out for missing details
- sequential execution, avoiding / Avoid sequential execution or "staircase"
- staircase pattern, avoiding / Avoid sequential execution or "staircase"
- span series, finish time / Be wary when things finish at exactly the same time
- trace points / Distributed tracing, Event model
- about / The idea
- tracer
- creating, in Java / Create a tracer in Java
- creating, in Python / Create a tracer in Python
- span, starting / Step 2 – start a span
- traceresolver module
- reference / Auto-instrumentation in Java
- tracer resolver
- reference / Tracer resolver
- about / Tracer resolver
- trace segment / Preserving causality
- tracing
- deployment / Anatomy of tracing deployment and interoperability
- interoperability / Anatomy of tracing deployment and interoperability
- activity / Five shades of tracing
- transactions, analyzing / Five shades of tracing
- transactions, recording / Five shades of tracing
- transactions, federating / Five shades of tracing
- transactions, describing / Five shades of tracing
- transactions, correlating / Five shades of tracing
- target audience / Know your audience
- ecosystem / The ecosystem
- benefits / Tracing as a knowledge base
- troubleshooting guide / Troubleshooting guide
- tracing instrumentation
- deploying, limitations / Why is it hard to deploy tracing instrumentation?
- Tracing Quality Metrics
- about / Tracing Quality Metrics
- completeness / Tracing Quality Metrics
- quality / Tracing Quality Metrics
- tracing systems
- about / Tracing systems
- Zipkin / Zipkin and OpenZipkin
- OpenZipkin / Zipkin and OpenZipkin
- Jaeger / Jaeger
- SkyWalking / SkyWalking
- X-Ray / X-Ray, Stackdriver, and more
- Stackdriver / X-Ray, Stackdriver, and more
- standard projects / Standards projects
- Tracing Talk chat application
- prerequisites / Prerequisites
- source code / Project source code
- about / The Tracing Talk chat application
- reference / The Tracing Talk chat application
- architecture / The Tracing Talk chat application
- executing / Running the application
- traces, observing / Observing traces
- instrumenting, with OpenTracing / Instrumenting with OpenTracing
- Tracing Talk chat application, implementation
- about / Implementation
- lib module / The lib module
- chat-api service / The chat-api service
- storage-service / The storage-service microservice
- giphy-service / The giphy-service microservice
- Tracing Talk chat application, prerequisites
- Java development environment / Java development environment
- Kafka, installing / Kafka, Zookeeper, Redis, and Jaeger
- Redis, installing / Kafka, Zookeeper, Redis, and Jaeger
- Zookeeper, installing / Kafka, Zookeeper, Redis, and Jaeger
- Jaeger, installing / Kafka, Zookeeper, Redis, and Jaeger
- tracing team
- objective / Don't be on the critical path
- traditional monitoring tools
- about / Traditional monitoring tools
- metrics / Metrics
- logs / Logs
- traffic labeling
- about / Traffic labeling
- testing, in production / Testing in production
- debugging, in production / Debugging in production
- developing, in production / Developing in production
- transport-level security (TLS) / Security
- trends
- observing / Observing trends
- extrapolations / Beware of extrapolations
U
- uDestroy / Chaos engineering
V
- variable-width dynamic metadata / Preserving causality
- virtualenv
- reference / Python development environment
W
- W3C / W3C "Data Interchange Format"
- W3C Trace Context / W3C Trace Context
- wget
- reference / Query tools (curl or wget)
- World Wide Web Consortium (W3C) / W3C Trace Context
X
- X-Ray / X-Ray, Stackdriver, and more
Z
- Zipkin / Zipkin and OpenZipkin
- zones / Running in multiple DCs