implementing-observability

Implement production observability across services using OpenTelemetry and the LGTM stack.

1|Updated Apr 8, 2026
One-click install
npx skills add https://github.com/masermediagroup-stack/CursorSkills --skill implementing-observability-masermediagroup-stack
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implementing-observability
Source: https://github.com/masermediagroup-stack/CursorSkills/tree/main/skills-bundle/skills/community/ai-design-components/skills/implementing-observability
Command: npx skills add https://github.com/masermediagroup-stack/CursorSkills --skill implementing-observability-masermediagroup-stack

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires requests, and includes scripts (resource) and references (resource) components.

What problem does it solve?

Production observability is often ad hoc and fragmented; this skill provides a structured approach to implementing end-to-end visibility using OpenTelemetry across metrics, logs, and traces, enabling reliable monitoring and faster incident response.

Core Features & Use Cases

  • Unified standard: Apply OpenTelemetry as the single framework for tracing, metrics, and logging across services.
  • LGTM stack guidance: Learn how to deploy and integrate Loki, Tempo, Grafana, and Mimir for self-hosted observability.
  • Auto-instrumentation & structured logging: Leverage auto-instrumentation strategies and log-trace correlation patterns to reduce boilerplate.
  • Dashboards & alerting: Build dashboards and alert rules to proactively monitor system health and performance.
  • Use Case: A microservice architecture can be instrumented once to produce end-to-end traces, correlated logs, and centralized dashboards for incident response.

Quick Start

Install dependencies, configure the LGTM stack, and instrument your app to start collecting traces, metrics, and logs.

Frequently Asked Questions about implementing-observability

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement OpenTelemetry for distributed tracing across microservices?

OpenTelemetry provides a unified standard for distributed tracing, metrics, and logging across microservices. This skill applies auto-instrumentation and structured logging to establish end-to-end visibility and enable faster incident response in production environments.

What is the best way to set up log-trace correlation using OpenTelemetry?

Log-trace correlation is best set up by leveraging OpenTelemetry auto-instrumentation strategies alongside structured logging patterns. This approach reduces boilerplate while linking your application logs directly to their originating traces for centralized observability.

How do I configure a self-hosted LGTM stack for production observability?

Configure the self-hosted LGTM stack by deploying and integrating Loki, Tempo, Grafana, and Mimir. This combination provides a comprehensive monitoring solution that collects metrics, logs, and traces to visualize system health through centralized dashboards.

Does this observability approach work with existing Prometheus metrics and Grafana dashboards?

Yes, this approach integrates seamlessly with existing Prometheus metrics and Grafana dashboards. It enforces the OpenTelemetry standard while utilizing Mimir for metrics scalability and Loki for centralized log aggregation within the same monitoring ecosystem.

How do I build alerting rules to monitor microservice health proactively?

Build alerting rules by configuring thresholds and conditions based on the metrics and traces collected via OpenTelemetry. This proactive monitoring setup triggers automated alerts to notify teams of system performance degradation or incidents.

When do I need OpenTelemetry for production observability instead of ad hoc monitoring?

You need OpenTelemetry when production observability becomes fragmented across services. It provides a structured approach to unify metrics, logs, and traces under a single framework, replacing ad hoc monitoring with reliable end-to-end visibility.