เมตริก แดชบอร์ด และความสามารถในการสังเกตระบบ

In production, knowing the health of your systems is critical. This lesson explores how to gather meaningful data about your applications and infrastructure.

We'll cover how metrics provide numerical insights and how dashboards visualize this data, leading to better observability.

Metrics are numerical measurements that describe system behavior or performance over time. Think of them as vital signs for your applications.

They help you track things like:

• How many requests your server handles
• The current CPU usage of a service
• The average response time for an API

By collecting metrics, you can spot trends and identify potential issues early.

One common type of metric is a Counter. A counter is a cumulative metric that only ever increases. It represents a total count of something over the lifetime of a service.

• Example: Total number of HTTP requests received.
• Example: Number of errors encountered.

Counters are great for tracking cumulative events.

Another fundamental metric type is a Gauge. Unlike counters, a gauge represents a single numerical value that can go up or down at any time.

It captures the current state of a particular aspect of your system.

• Example: Current CPU utilization (e.g., 55%).
• Example: Number of active users logged in.
• Example: Current memory usage.

Gauges show you instantaneous values.

Histograms sample observations and store them in configurable buckets. They are powerful for understanding the distribution of values, like request durations.

Instead of just an average, a histogram can tell you:

• Most requests finish in 100ms.
• Some requests take 500ms.
• Very few requests take over 1 second.

This helps you see performance outliers.

Similar to histograms, Summaries also sample observations, often focusing on configurable quantiles (or percentiles) over a sliding time window.

For example, a summary might report the 50th percentile (p50), 90th percentile (p90), and 99th percentile (p99) of request latency.

• p99 latency: 99% of requests complete within this time.

This gives insights into the experience of the majority, and the slowest, users.

Metrics are typically collected by instrumenting your application code or using agents that monitor your infrastructure. Here's a conceptual look at how you might increment a counter:

A dashboard is a graphical user interface that presents key metrics and data in an easy-to-understand visual format. It's your central hub for monitoring system health.

Good dashboards provide an at-a-glance overview, allowing you to quickly identify if something is wrong without diving into raw data.

• They turn numbers into charts and graphs.
• They help spot trends and anomalies.

To make dashboards truly useful, follow these best practices:

• Focus: Display only the most critical metrics for a specific purpose.
• Clarity: Use clear labels, appropriate chart types, and consistent colors.
• Actionable: Design dashboards that help you understand what's happening and guide your next steps.
• Audience: Tailor dashboards for different roles (e.g., engineers, product managers).

Observability is the ability to infer the internal state of a system by examining its external outputs. It goes beyond simple monitoring.

While monitoring tells you if something is wrong, observability helps you understand why it's wrong and what's happening inside the system to cause it.

It relies on three pillars: Metrics, Logs, and Traces, working together to provide a complete picture.

Which of the following statements about metrics and dashboards are generally TRUE?

Great job! In this lesson, you've learned about the fundamentals of monitoring your systems effectively.

• Metrics are numerical data points (Counters, Gauges, Histograms, Summaries) that describe system behavior.
• Dashboards visualize these metrics, offering a clear, actionable view of your system's health.
• Observability combines metrics with logs and traces to help you understand not just *what* is happening, but *why*.

These tools are essential for proactive problem detection and efficient debugging in production!