Debug & Harden Production [Bundle of 3 Books]

A hands-on, recipe-driven book that puts OpenTelemetry into immediate use. This cookbook is for IT folks like developers, Linux admins, cloud engineers, backend pros, networking experts, and security practitioners. It's for anyone who wants a proven, hands-on way to keep an eye on, trace, and understand modern systems.

This book gives you step-by-step easy solutions to everyday observability challenges, so you can integrate, configure, and operate OpenTelemetry in dynamic environments. Each chapter focuses on solving problems that are directly relevant to production teams. These problems include installing and bootstrapping the Collector on Linux, wiring telemetry pipelines for traces, metrics, logs, and baggage, and integrating with the platforms that organizations trust for analysis and alerting.

• Get the OpenTelemetry Collector up and running on Linux, Docker, and Kubernetes.
• Make and adjust pipelines to collect, process, and send out different telemetry signals.
• Use it to develop apps across Python, Go, Java, and Node.js.
• Boost signals with semantic info and resource detectors for more context.
• Integrate with AWS CloudWatch, X-Ray, Elastic, Prometheus, Splunk, Datadog, New Relic, Grafana Tempo, Loki, and Jaeger.
• Make a visual plan for telemetry and set up real-time alerts.

There's no need to get lost in theoretical jargon because OpenTelemetry Cookbook gets right to the meat and potatoes of implementation. Every recipe gives you a clear problem statement, a step-by-step solution, and practical validation. If you're just starting out with observability or want to level up your skills, this book's got you covered with clear steps to understand distributed, cloud-native, and hybrid systems.

This book builds a solid foundation for strong, easy-to-spot infrastructure and application settings, one step at a time. This book isn't about offering quick fixes or magic solutions. It gives you a full set of tools and techniques that help professionals improve visibility, performance, and reliability in their own technical landscapes.

1. Bootstrapping OpenTelemetry
2. Building Telemetry Pipelines
3. Instrumenting Applications with OpenTelemetry SDKs
4. Code-Based Instrumentation and Auto-Instrumentation
5. Telemetry with Attributes and Resource Detectors
6. Advanced Signal Processing and Filtering
7. Observability in Kubernetes
8. Integrations with Cloud and Observability Platforms
9. Visualizing and Alerting Telemetry Data

These days, every company runs on software of which they can't see the full picture. There are orders that fail quietly at two in the morning, a checkout that takes forever to service one customer, and a nightly job that stops running for a week before anyone even notices. So, we've got these standard monitoring reports that say the servers are all good, even though the business is losing money behind the scenes.

With Sentry, you can debug in production and close that gap. This book takes a live system from silence to something that explains itself by working through a single storefront application built with Python and JavaScript. You install error monitoring, join three runtimes into one distributed trace, record the customer's own session, bring structured logs alongside those traces, and profile the exact function spending the time. Then the book moves on to how to run it well. You set alerts that people act on, not mute. And you can build a dashboard that the team will actually open.You can catch jobs that fail by never starting, and hand difficult issues to Sentry's Seer agent while keeping your own judgement firmly in charge.

• Instrument a full-stack application so every failure names its file, line and owner.
• Join browser, API and worker into one trace across the network boundary.
• Read a span waterfall and locate the slow span within two minutes.
• Detect and remove N+1 query patterns using trace evidence rather than guesswork.
• Record and mask customer sessions, proving privacy from the stored payload itself.
• Correlate structured logs with traces so caught errors stop disappearing entirely.
• Profile production safely and name the exact function consuming the time.
• Detect silent failures using uptime checks and scheduled job check-ins.
• Derive alert thresholds from real history instead of instinct or round numbers.
• Review an AI root cause analysis critically before accepting any proposed fix.

1. Installing Sentry cross Stack
2. Making Errors Readable
3. Setting up Distributed Tracing
4. Finding Slow Code in Traces
5. Replaying User Sessions
6. Correlating Logs with Errors
7. Profiling Slow Functions
8. Using Insights Dashboards
9. Monitoring Uptime, Crons and Metrics
10. Building Alerts and Dashboards
11. Debugging with Seer
12. Keeping Sentry Healthy

Whether you're an engineer, SRE or tech lead, you'll find everything you need to scale your company. All the tasks are routine, you can reproduce them and verify the results. Basics of application monitoring and knowing the lifecycle of application development is all you need to get through this book.

How long do you think it would take you to notice if your AI system started giving worse answers?

Honestly, for most teams, it's weeks, and the news comes from a customer. Chaos engineering answers that question for infrastructure in about thirty seconds, because if a server goes down, it either reroutes or it doesn't. And language models completely shatter all those assumptions. Their output varies for real, their decay builds up instead of happening straight away, and those failures are confident, plausible, and wrong while latency, error rate, and pod health stay exactly where they should be.

This book sets out the new framework for AI infrastructure. You'll find that, working through one support-assistant application across twelve chapters, everything moves from defining steady state for probabilistic systems to injecting faults at every layer, including accelerators, inference servers, model artefacts, retrieval pipelines, model APIs, autonomous agents, distributed training and the monitoring stack itself.

Just to be clear, the toolchain is intentionally kept small. The LitmusChaos orchestrates, the Chaos Mesh reaches the kernel and filesystem, and the mitmproxy handles the content-level faults that neither can touch, extended with custom injectors where nothing suitable exists. So, every experiment comes to one of these four conclusions, and then the last chapter sums them all up as a programme scorecard.

• Write down what "working correctly" means when your system's output legitimately varies.
• Break GPUs and inference servers on purpose, with a restore path that always runs.
• Spot the failures that keep every dashboard green and every alert silent.
• Check model weights for damage before loading them, not after serving starts.
• Catch the model release that scores better overall while getting worse where it matters.
• Find out whether your RAG pipeline is helping, or quietly making answers worse.
• Corrupt what the model returns, then watch whether your agent notices.
• Stop your remediation agent from making an incident worse than it was.
• Prove your training checkpoints actually resume the run they claim to continue.
• Catch slow decay in hours instead of days by changing how you alert.

1. Why AI Systems Fail Differently?
2. Steady State for Probabilistic System
3. Lab and the Toolchain
4. Accelerator and Compute Chaos
5. Inference Serving Chaos
6. Model Artifacts, Registries, and Version Skew
7. Retrieval and Context Chaos
8. Model-Boundary Chaos
9. Agentic and Multi-Agent Chaos
10. Distributed Training and Choas Fine-Tuning
11. Observing Probabilistic Degradation
12. Operationalizing Chaos