Cloud-Native Observability with OpenTelemetry: Learn to gain visibility into systems by combining tracing, metrics, and logging with OpenTelemetry

Length: 386 pages
Edition: 1
Language: English
Publisher: Packt Publishing
Publication Date: 2022-05-04
ISBN-10: 1801077703
ISBN-13: 9781801077705
Sales Rank: #1835522 (See Top 100 Books)

Leverage OpenTelemetry’s API, libraries, tools and the collector to produce and collect telemetry along with using open-source tools to analyze distributed traces, check metrics and logs, and gain insights into application health

Key Features

Get to grips with OpenTelemetry, an open-source cloud-native software observability standard
Use vendor-neutral tools to instrument applications to produce better telemetry and improve observability
Understand how telemetry data can be correlated and interpreted to understand distributed systems

Book Description

Cloud-Native Observability with OpenTelemetry is a guide to helping you look for answers to questions about your applications. This book teaches you how to produce telemetry from your applications using an open standard to retain control of data. OpenTelemetry provides the tools necessary for you to gain visibility into the performance of your services. It allows you to instrument your application code through vendor-neutral APIs, libraries and tools.

By reading Cloud-Native Observability with OpenTelemetry, you’ll learn about the concepts and signals of OpenTelemetry – traces, metrics, and logs. You’ll practice producing telemetry for these signals by configuring and instrumenting a distributed cloud-native application using the OpenTelemetry API. The book also guides you through deploying the collector, as well as telemetry backends necessary to help you understand what to do with the data once it’s emitted. You’ll look at various examples of how to identify application performance issues through telemetry. By analyzing telemetry, you’ll also be able to better understand how an observable application can improve the software development life cycle.

By the end of this book, you’ll be well-versed with OpenTelemetry, be able to instrument services using the OpenTelemetry API to produce distributed traces, metrics and logs, and more.

What you will learn

Understand the core concepts of OpenTelemetry
Explore concepts in distributed tracing, metrics, and logging
Discover the APIs and SDKs necessary to instrument an application using OpenTelemetry
Explore what auto-instrumentation is and how it can help accelerate application instrumentation
Configure and deploy the OpenTelemetry Collector
Get to grips with how different open-source backends can be used to analyze telemetry data
Understand how to correlate telemetry in common scenarios to get to the root cause of a problem

Who this book is for

This book is for software engineers, library authors, and systems operators looking to better understand their infrastructure, services and applications by leveraging telemetry data like never before. Working knowledge of Python programming is assumed for the example applications that you’ll be building and instrumenting using the OpenTelemetry API and SDK. Some familiarity with Go programming, Linux, and Docker is preferable to help you set up additional components in various examples throughout the book.

Cloud-Native Observability with OpenTelemetry
Foreword
Contributors
About the author
About the reviewer
Preface
    Who this book is for
    What this book covers
    To get the most out of this book
    Download the example code files
    Download the color images
    Conventions used
    Get in touch
    Share Your Thoughts
Section 1: The Basics
Chapter 1: The History and Concepts of Observability
    Understanding cloud-native applications
    Looking at the shift to DevOps
    Reviewing the history of observability
        Centralized logging
        Using metrics and dashboards
        Applying tracing and analysis
    Understanding the history of OpenTelemetry
        OpenTracing
        OpenCensus
        Observability for cloud-native software
    Understanding the concepts of OpenTelemetry
        Signals
        Pipelines
        Resources
        Context propagation
    Summary
Chapter 2: OpenTelemetry Signals – Traces, Metrics, and Logs
    Technical requirements
    Traces
        Anatomy of a trace
        Details of a span
        Additional considerations
    Metrics
        Anatomy of a metric
        Data point types
        Exemplars
        Additional considerations
    Logs
        Anatomy of a log
        Correlating logs
        Additional considerations
        Semantic conventions
    Summary
Chapter 3: Auto-Instrumentation
    Technical requirements
    What is auto-instrumentation?
        Challenges of manual instrumentation
        Components of auto-instrumentation
        Limits of auto-instrumentation
    Bytecode manipulation
        OpenTelemetry Java agent
    Runtime hooks and monkey patching
        Instrumenting libraries
        The Instrumentor interface
        Wrapper script
    Summary
Section 2: Instrumenting an Application
Chapter 4: Distributed Tracing – Tracing Code Execution
    Technical requirements
    Configuring the tracing pipeline
        Getting a tracer
    Generating tracing data
        The Context API
        Span processors
    Enriching the data
        ResourceDetector
        Span attributes
        SpanKind
    Propagating context
        Additional propagator formats
        Composite propagator
    Recording events, exceptions, and status
        Events
        Exceptions
        Status
    Summary
Chapter 5: Metrics – Recording Measurements
    Technical requirements
    Configuring the metrics pipeline
        Obtaining a meter
        Push-based and pull-based exporting
    Choosing the right OpenTelemetry instrument
        Counter
        Asynchronous counter
        An up/down counter
        Asynchronous up/down counter
        Histogram
        Asynchronous gauge
        Duplicate instruments
    Customizing metric outputs with views
        Filtering
        Dimensions
        Aggregation
    The grocery store
        Number of requests
        Request duration
        Concurrent requests
        Resource consumption
    Summary
Chapter 6: Logging – Capturing Events
    Technical requirements
    Configuring OpenTelemetry logging
    Producing logs
        Using LogEmitter
        The standard logging library
    A logging signal in practice
        Distributed tracing and logs
        OpenTelemetry logging with Flask
        Logging with WSGI middleware
        Resource correlation
    Summary
Chapter 7: Instrumentation Libraries
    Technical requirements
    Auto-instrumentation configuration
        OpenTelemetry distribution
        OpenTelemetry configurator
        Environment variables
        Command-line options
    Requests library instrumentor
        Additional configuration options
        Manual invocation
        Double instrumentation
    Automatic configuration
        Configuring resource attributes
        Configuring traces
        Configuring metrics
        Configuring logs
        Configuring propagation
    Revisiting the grocery store
        Legacy inventory
        Grocery store
        Shopper
    Flask library instrumentor
        Additional configuration options
    Finding instrumentation libraries
        OpenTelemetry registry
        opentelemetry-bootstrap
    Summary
Section 3: Using Telemetry Data
Chapter 8: OpenTelemetry Collector
    Technical requirements
    The purpose of OpenTelemetry Collector
    Understanding the components of OpenTelemetry Collector
        Receivers
        Processors
        Exporters
        Extensions
        Additional components
    Transporting telemetry via OTLP
        Encodings and protocols
        Additional design considerations
    Using OpenTelemetry Collector
        Configuring the exporter
        Configuring the collector
        Modifying spans
        Filtering metrics
    Summary
Chapter 9: Deploying the Collector
    Technical requirements
    Collecting application telemetry
        Deploying the sidecar
    System-level telemetry
        Deploying the agent
        Connecting the sidecar and the agent
        Adding resource attributes
    Collector as a gateway
        Autoscaling
        OpenTelemetry Operator
    Summary
Chapter 10: Configuring Backends
    Technical requirements
    Backend options for analyzing telemetry data
        Tracing
        Metrics
        Logging
    Running in production
        High availability
        Scalability
        Data retention
        Privacy regulations
    Summary
Chapter 11: Diagnosing Problems
    Technical requirements
    Introducing a little chaos
        Experiment #1 – increased latency
        Experiment #2 – resource pressure
        Experiment #3 – unexpected shutdown
    Using telemetry first to answer questions
    Summary
Chapter 12: Sampling
    Technical requirements
    Concepts of sampling across signals
        Traces
        Metrics
        Logs
        Sampling strategies
        Samplers available
    Sampling at the application level via the SDK
    Using the OpenTelemetry Collector to sample data
        Tail sampling processor
    Summary
    Why subscribe?
Other Books You May Enjoy
    Packt is searching for authors like you
    Share Your Thoughts

Linux Linux & UNIX Administration Network Administration Networking & System Administration Systems Analysis & Design

Donate to keep this site alive

To access the Link, solve the captcha.

How to download source code?

1. Go to: https://github.com/PacktPublishing

2. In the Find a repository… box, search the book title: Cloud-Native Observability with OpenTelemetry: Learn to gain visibility into systems by combining tracing, metrics, and logging with OpenTelemetry, sometime you may not get the results, please search the main title.