Skill UI

This skill guides the setup of distributed tracing and performance monitoring using Sentry. It covers configuring the SDK (e.g., setting tracesSampleRate) to capture latency, identify performance bottlenecks, and trace requests across the entire application stack. It demonstrates how to create manual spans for business logic and utilizes profiling for deeper performance insights, ensuring comprehensive application observability.

This guide provides enterprise-grade architectural patterns for integrating Sentry into multi-service, microservices environments. It covers centralized configuration modules, standardized project topologies (e.g., one project per service), distributed tracing setup, and robust error handling middleware for Node.js, Express, and Python/FastAPI. Ideal for organizations planning large-scale Sentry rollouts or managing complex service ecosystems.

Automates setting up distributed tracing across a microservices landscape by guiding backend selection, instrumentation strategy, and configuration generation to enable end-to-end observability and aid performance troubleshooting.

A comprehensive guide to implementing observability for Klaviyo API integrations. This solution uses Prometheus metrics (counters, histograms, gauges) to track API volume, latency, and errors, combined with OpenTelemetry for distributed tracing and structured logging. Ideal for setting up robust monitoring dashboards and critical alerting systems for marketing data pipelines.

This guide details how to implement comprehensive observability for various Adobe API integrations (e.g., Firefly, PDF Services). It covers the four pillars of observability: structured metrics using Prometheus, distributed tracing via OpenTelemetry, structured JSON logging, and defining critical alert rules. This ensures deep visibility into API performance, latency, and error rates for robust production monitoring.

This skill provides a comprehensive guide to instrumenting Algolia search services for enterprise-grade observability. It integrates core monitoring patterns, including Prometheus metrics (latency, error rates, request counts), OpenTelemetry distributed tracing, and structured logging. Use this to achieve deep insights into search performance, user experience, and system health in production environments.

Implement comprehensive observability for Canva Connect API integrations using industry best practices. This guide covers gathering critical metrics (latency, error rates, rate limits) with Prometheus, implementing distributed tracing with OpenTelemetry, and setting up robust alert rules. Essential for monitoring API health, optimizing performance, and ensuring system reliability in SaaS environments.

This skill provides comprehensive observability for ClickUp API integrations. It instruments API calls to capture key metrics like request rate, latency percentiles, error counts, and rate limit usage. It integrates with Prometheus for metrics, OpenTelemetry for distributed tracing, and structured logging for detailed event tracking. Use it to build robust dashboards and set up critical alerts for API performance issues.

Implement a comprehensive observability stack for Webflow Data API v2 integrations. This skill provides structured code using Prometheus metrics, OpenTelemetry distributed tracing, and structured logging (pino) to monitor API call frequency, latency, error rates, and rate limit usage. Ideal for developers building robust, production-grade Webflow-connected SaaS applications that require deep performance insights and reliable alerting.

This extension provides comprehensive distributed tracing capabilities for the KubeSphere Observability Platform, adhering to the OpenTelemetry standard. It guides users through the entire lifecycle, including component installation (Generator, Collector, Agent), configuration, and querying complex tracing data, spans, and service graphs. It is essential for monitoring microservices and understanding complex system interactions.

This guide details the principles of observability, teaching developers how to instrument code by implementing structured logging, metrics, and distributed tracing. It ensures that production features emit sufficient telemetry to answer complex operational questions, transforming unknown failures into diagnosable events. Essential for any service running in production.