Chapter 9 is here! Observability for Serverless Rust 🔭

Hello again, serverless Rustaceans 🦀

We're back with another release, and this one shines a light on something that often gets neglected until 3am on a Saturday: observability.

If you've ever stared at CloudWatch logs wondering "but WHY did it fail?" or tried to trace a request through an event-driven system only to lose it somewhere between SQS and your downstream Lambda, this chapter is for you.

TLDR; for the busy ones:

• Chapter 9 is out: Observability for serverless applications using OpenTelemetry, including both synchronous and asynchronous processes

• E-reader fixes: Code snippets now render properly in epub format (Kindle and iBooks users, rejoice!)

• Dependency upgrade: Switched to reqwest 0.13 with rust-tls enabled by default

• DX improvements: Better ergonomics for batch responses when processing SQS and Kinesis events

Alright, do you want the full details? Let's jump in!

Chapter 9 is here! Observability with OpenTelemetry 🔭

After building event-driven systems in Chapter 8, you might have noticed something: when things go wrong in distributed, asynchronous flows, figuring out what went wrong becomes... interesting.

This chapter tackles that head-on.

We start with the fundamentals. What observability actually means (spoiler: it's definitely not just logs), why traditional monitoring approaches often fall short in serverless, and what makes event-driven systems particularly tricky to observe.

Then we dive deep into OpenTelemetry: the open standard that's rapidly becoming the way to instrument applications. We cover:

• Traces, metrics, and logs — the three pillars and how they work together

• Semantic conventions — why standardisation matters and how it makes your life easier

• Implementing OpenTelemetry in Rust — practical, working code you can adapt

• Local development — because you shouldn't need to deploy to see what's happening

• Dealing with PII — a topic that's easy to overlook until it bites you

• Opinionated guidance — our take on building a sensible observability strategy for serverless

As always, we do all of this in the context of our trusty URL shortener application. You'll instrument both the synchronous API endpoints and the asynchronous event-driven components we built in Chapter 8. By the end, you'll be able to trace a request from the initial API call, through SQS, and into your downstream processors.

We hope this chapter helps you spend less time squinting at logs and more time building features!

Other improvements across the book 💅

This release includes several quality-of-life improvements beyond the new chapter.

E-reader code rendering fixed

We heard from readers that code snippets were rendering poorly on Kindle and iBooks. We've gone through and fixed the epub formatting, so code should now be much more readable on your e-reader of choice. If you spot any remaining issues, please let us know!

Upgraded to reqwest 0.13

We've updated to reqwest 0.13, which ships with rust-tls enabled by default. This simplifies our dependencies and means you no longer need to fiddle with feature flags to get TLS working properly. One less thing to think about.

Improved batch response ergonomics

If you've worked with SQS or Kinesis batch processing, you know that building batch responses can be a bit tedious. The aws-lambda-rust-runtime team has improved the ergonomics of SqsBatchResponse and KinesisEventResponse, and we've updated our examples to take advantage of these improvements. The code is now cleaner and less error-prone.

📦 How to get the new release

If you already have a copy of Crafting Lambda Functions in Rust, grabbing the latest release is easy!

1. Head over to Gumroad, log in, and open up your product library.

2. You'll see a list of all your purchased products. Look for "Crafting Lambda Functions in Rust (e-book)".

3. Click on it, and voilà! You'll find all the updated download links right there.

If you have the Gumroad mobile app the process should be similar!

All updated code examples are also available in our code repository, so you can dive into the latest examples straight away.

If you hit any snags along the way, reach out, we're here to help!

🔮 What's next: Chapter 10 (Middlewares) 👀

We're already hard at work on Chapter 10, and this one is all about middlewares.

If you've ever found yourself copy-pasting the same tracing setup, error handling, or request validation across multiple Lambda functions, you'll appreciate what's coming. We'll explore how to build reusable middleware layers that keep your handler code focused on business logic.

We're excited about this one. Watch this space!

There might even be a little crate winding it’s way to crates.io to provide some out of the box defaults.

🫶 We need your help

This book is a project of love that we build off-hours, so any help you can give is golden.

If you want to contribute, here are a few high-impact ways:

Tell us what works and what does not. If you spot typos, confusing sections, or places where you think "this could be explained better," please tell us.

Show us your Rust and Lambda creations. If you are building something with Rust on Lambda, we would love to see it. Share your projects in our Discord community or reply with a short description and links. With your permission, we might feature some of them as examples or case studies.

Join the conversation on Discord. That is where we bounce ideas, discuss patterns, and occasionally rant about tooling. If you are not there yet, this is your invitation to join, say hi, and tell us what you would like to see more of in the book.

Thank you again for reading, for experimenting with Rust on Lambda, and for keeping us accountable and motivated to make this book the most practical guide we can.

Happy building! 🦀

— Luciano & James