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
  • about / Feature extraction, Feature extraction exercise
• 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
  • tracing / Exercise 3 – tracing functions and passing context

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