FaaS Observability Basics
What You'll Learn
You'll learn how to monitor and understand what's happening inside your serverless functions using logging, metrics, and tracing.
Why Observability Matters for Functions
Since serverless functions are ephemeral (they come and go quickly) and managed by the provider, you can't SSH into a server to investigate problems. You need specialized observability tools to understand function behavior, diagnose issues, and optimize performance.
Think of observability like having security cameras, temperature sensors, and activity logs in your house—you need multiple perspectives to understand what's really happening.
The Three Pillars of FaaS Observability
Logging
Function logs capture what happened during execution—print statements, error messages, and debug information. Every function invocation can write log entries that persist after the function finishes. These logs answer questions like "Did this function run?" and "What error occurred?"
Metrics
Metrics provide quantitative measurements about function behavior: invocation count, execution duration, memory usage, error rates, and concurrency levels. Unlike logs, metrics are numerical and easy to graph over time. They answer "How many times did this fail?" and "Is performance degrading?"
Tracing
Distributed tracing shows the complete path of a request as it flows through multiple functions and services. When one function triggers another—or calls a database—tracing connects these events into a single timeline. This answers "Why is this request slow?" by revealing bottlenecks across your entire event chain.
Using These Together
These three tools complement each other: metrics alert you to a problem, logs help diagnose the cause, and traces reveal how issues propagate through your system. Cloud providers automatically collect basic metrics, but you'll need to instrument your function code to generate meaningful logs and traces.
Key Takeaway: FaaS observability relies on logging (what happened), metrics (how much/how often), and tracing (end-to-end flow) to monitor ephemeral, event-driven functions you can't directly inspect.