uptrace/uptrace

Features

• Distributed Tracing Instrumentation - Implements distributed tracing to visualize request flows and transactions across multiple services using spans.
• OpenTelemetry Ingestion - Collects traces, metrics, and logs using the standardized OpenTelemetry protocol for vendor-agnostic ingestion.
• Observability Stacks - Functions as a complete OpenTelemetry-based platform for collecting, storing, and analyzing distributed traces, metrics, and logs.
• Distributed Tracing - Visualizes the full execution path of requests across multiple services using waterfall timelines.
• OpenTelemetry Standard Integrations - Implements a complete observability stack using OpenTelemetry standards for tracing, metrics, and logging.
• AI Observability Tracing - Captures LLM API metadata, including token usage and model versions, using GenAI semantic conventions.
• Natural Language Telemetry Querying - Exposes spans, traces, and metrics to AI assistants for telemetry analysis using natural language.
• AI-Powered Observability Analysis - Uses large language models to allow natural language querying of telemetry and automated management of monitoring dashboards.
• Pipeline Stage Tracing - Monitors every step of a Retrieval-Augmented Generation workflow, including embedding, vector search, and LLM calls.
• Model Performance Analysis - Analyzes token usage and response quality across model versions using generative AI attributes.
• AI Observability and Evaluation - Provides specialized capturing of LLM prompts and completions for AI observability and evaluation.
• Logging and Monitoring - Provides an interface for browsing, filtering, and inspecting grouped application logs and error telemetry.
• Analytics Metrics Querying - Executes PromQL-compatible queries with joins and grouping to analyze application performance metrics.
• Application Metrics Collection - Collects numerical telemetry using synchronous and asynchronous instruments to monitor application performance.
• OTLP Exporters - Transmits numeric measurements and counters using the OpenTelemetry Protocol (OTLP) to track system health.
• OTLP Ingestion - Collects traces, metrics, and logs from an OpenTelemetry Collector using the OTLP protocol.
• Unified Observability SQL Querying - Filters and aggregates spans, logs, and events using a unified query language for performance analysis.
• Metric Query Languages - Aggregates and filters time-series metrics using a PromQL-compatible query language.
• PromQL-Compatible Engines - Provides a time-series data store with PromQL-compatible querying for aggregating performance measurements.
• Telemetry Query Languages - Filters and aggregates traces, logs, and metrics using specialized and Prometheus-compatible query languages.
• Telemetry Record Filtering - Filters telemetry records using natural language syntax and attribute-scoped queries to locate spans or logs.
• Request Spans - Captures incoming web requests as spans to visualize the request flow and allow URL-based filtering.
• Topology Visualizers - Generates an automatic map of service dependencies, request rates, and error rates based on observed spans.
• Service Health Monitoring - Tracks request rates, error percentages, and p99 latency across service boundaries to monitor operational status.
• Telemetry Collectors - Forwards telemetry from an OpenTelemetry Collector to backends using dedicated exporters for traces, metrics, and logs.
• Distributed Trace Propagation - Propagates trace contexts across service boundaries to reconstruct request paths in microservices.
• Auto-Instrumentation - Automatically injects tracing and metrics collection into client-side requests and server-side responses.
• Tracing Context Propagation - Injects and extracts distributed tracing headers across network boundaries to maintain a continuous request correlation.
• Contextual Metadata Propagation - Implements mechanisms for propagating request-scoped metadata and trace identifiers across application execution flows.
• Event Logging - Records application software events using standard logging libraries or direct attachments to distributed traces.
• Metadata Propagation - Transmits user-defined contextual key-value pairs across service boundaries to support multi-tenant filtering and A/B testing.
• Alert Thresholds - Defines numerical limits and rules to trigger notifications when metrics or error rates exceed specified thresholds.
• Application Metric Tracking - Records performance data using counters, histograms, and gauges to track system health.
• Application Performance Monitoring - Tracks system health and resource utilization through custom metrics, error alerts, and real-time performance dashboards.
• Automatic Tracing Instrumentation - Uses auto-instrumentation to collect distributed traces, metrics, and logs for monitoring production system health.
• Centralized Logging Systems - Provides a centralized backend for aggregating, indexing, and storing structured application logs correlated with traces.
• Distributed Request Tracking - Provides capabilities to track request lifecycles via spans and parent-child relationships in distributed systems.
• Distributed Tracing - Gathers and stores distributed tracing data using OpenTelemetry SDKs for request flow analysis.
• Distributed Tracing Systems - Implements a distributed tracing architecture to visualize request lifecycles across microservices via waterfalls and dependency maps.
• Framework Instrumentation - Automatically generates traces for common HTTP clients, database drivers, and web servers via pre-built integrations.
• Log Ingestion - Ingests logs from containers and correlates them with distributed traces to accelerate troubleshooting.
• Trace-to-Log Mappers - Extracts trace and span identifiers from log attributes to correlate log entries with tracing data.
• Bidirectional Trace-Log Navigation - Injects trace and span identifiers into logs to enable seamless bidirectional navigation between logs and traces.
• Log Search Engines - Enables full-text search and metadata filtering of logs with bidirectional links to distributed traces.
• Unified Observability Ingestion - Collects traces, metrics, and logs using native SDKs, collectors, or eBPF via a unified OpenTelemetry backend.
• System Metrics Collection - Gathers native system-level performance metrics including CPU and memory usage to monitor infrastructure health.
• Metric Dashboards - Visualizes infrastructure and application health using pre-built or custom layouts featuring tables and grids.
• Custom Metric Dashboards - Allows users to create custom visual displays of spans, events, logs, and metrics via a UI or YAML configuration.
• AI-Powered Analysis Engines - Integrates large language models to enable natural language telemetry querying and automated dashboard management.
• Performance Visualization - Transforms telemetry data into visual dashboards to track performance trends such as worker exhaustion and queue growth.
• Telemetry Processing Engines - Provides a scalable intermediary to collect, process, and route telemetry data from various sources.
• GenAI Execution Monitoring - Provides specialized tracing for LLM interactions and RAG workflows, tracking token usage and response quality.
• Observability Platforms - Offers a complete backend for collecting and analyzing traces, metrics, and logs adhering to OpenTelemetry standards.
• Trace Exporters - Sends distributed tracing data to remote collectors via gRPC or HTTP to monitor request flows.
• Trace Context Extraction - Extracts trace and baggage context from incoming HTTP request headers or message queue metadata.
• Trace Context Injection - Injects trace and baggage context into outgoing HTTP requests or message queue headers.
• OpenTelemetry Exporters - Sends traces, metrics, and logs to monitoring systems using the OpenTelemetry Protocol.
• Prometheus Metric Ingestion - Provides native support for importing Prometheus metrics via remote write and collector receivers while maintaining PromQL compatibility.
• Service Dependency Mapping - Maps real-time request flows and service interactions by transforming span relationships into a directed graph.
• Structured Logging - Provides structured logging capabilities to emit machine-readable key-value pairs for precise telemetry filtering.
• Trace-Context - Links application logging frameworks to tracing pipelines by attaching unique trace and span identifiers to log entries.
• Trace Context Management - Tracks active spans across execution boundaries to maintain parent-child relationships in distributed traces.
• Trace Querying - Filters and selects entire traces based on the spans, logs, and events they contain.
• Trace Sampling - Controls the volume of generated spans using ratio or parent-based strategies to reduce storage costs.
• Trace Waterfall Visualizations - Provides a visual breakdown of span durations, errors, and attributes for a single request.
• Telemetry Attribute Normalizers - Applies OpenTelemetry semantic conventions to ensure consistent naming of attributes across different services.
• Pipeline Performance Alerting - Triggers notifications for empty retrieval results or latency spikes within AI pipelines.
• Tail-Based Sampling - Phoenix ensures traces containing errors or exceeding duration thresholds are captured while sampling successful operations.
• Columnar Telemetry Transport - Transports tracing, metrics, and logs using the OTel Arrow columnar format to reduce bandwidth consumption.
• Consumer Lag Monitoring - Collects consumer group status, partition offsets, and lag metrics to monitor Kafka health.
• Business Metrics - Provides tools for defining and calculating domain-specific business performance indicators using counters and histograms.
• Kubernetes Cluster Context - Enriches raw telemetry with Kubernetes-specific metadata such as pods, services, and namespaces.
• Syslog Ingestion - Supports receiving and parsing log messages via TCP or UDP using RFC 3164 and 5424 Syslog protocols.
• Script-Based Transformations - Executes arbitrary expressions to modify telemetry, such as normalizing cardinality or parsing strings.
• Data Retention Policies - Defines how long traces, metrics, and logs are kept before automatic deletion to manage capacity.
• Data Sharding - Distributes ingestion volumes across multiple independent database nodes using weighted round-robin writes.
• Observability Transformation Languages - Manipulates raw attribute values using string functions or type casting to normalize telemetry data.
• Attribute-Based Grouping - Allows manual definition of span or event clusters using specific attribute fingerprints.
• Database Backup and Restoration - Creates and restores snapshots of underlying databases to prevent data loss during failures.
• Full-Text Search Indexes - Builds case-insensitive token-based indexes from attributes to enable advanced full-text search.
• Full-Text Indexes on Log Columns - Creates full-text indexes on specified attributes for fast keyword searching across logs and spans.
• Distributed Sharding Architectures - Distributes telemetry ingestion volumes across multiple independent database nodes using weighted round-robin sharding.
• External Storage Integrations - Integrates with external Redis, PostgreSQL, or ClickHouse instances for enhanced data control.
• High Availability Configurations - Sets up redundant clusters for storage and caching using replicas and primary-standby mirroring.
• Horizontal Scaling - Supports horizontal scaling to process high volumes of telemetry spans per second.
• Storage Tiering - Distributes telemetry across SSD, HDD, and S3-compatible storage to optimize for both query speed and cost.
• ORM Performance Monitors - Automatically generates spans and captures query text for database operations using ORMs like TypeORM and Prisma.
• Resource Tagging - Attaches metadata to services, processes, or containers to enable efficient filtering and grouping of telemetry.
• Application Instance Deployments - Installs the system and database dependencies via Docker Compose, Helm charts, or Ansible.
• Bare Metal Server Deployments - Uses Ansible playbooks and roles to install and configure the platform on physical servers.
• Configuration as Code - Defines organizations, projects, and monitors using Terraform or YAML for version-controlled observability configuration.
• Zero-Code Instrumentation - Enables telemetry collection via environment variables and registration flags without requiring source code modifications.
• Error Tracking and Exception Handling - Correlates captured exceptions and stack traces with distributed trace contexts to map error flow.
• Horizontal Scaling Strategies - Distributes traffic across multiple stateless instances using a load balancer to increase throughput.
• Log Event Clustering - Clusters similar log entries together using unique fingerprints to identify recurring event patterns.
• Infrastructure Event Correlation Tools - Links distributed tracing spans with underlying infrastructure metrics and network data for operational context.
• Observability Operator Automation - Injects observability plugins into pods and manages collector lifecycles using a native operator.
• Noise-Reducing Alert Grouping - Provides intelligent alert configuration with noise-reducing grouping and multi-channel routing.
• Conditional Log Routings - Directs log records to different processing paths based on specific attributes or expressions.
• Per-Tenant Ingestion Rate Limiters - Caps the number of traces processed per second on the server side to prevent system overload.
• Web Server Metrics - Automatically records request durations, body sizes, and concurrent active request counts for web servers.
• Serverless Telemetry - Tracks execution times and cold start occurrences for serverless functions to provide operational visibility.
• Telemetry Data Pipelines - Collects, transforms, and exports telemetry data through a vendor-agnostic pipeline to multiple backends.
• Enterprise Identity Providers - Connects to external enterprise identity providers such as Okta and Keycloak for centralized single sign-on.
• SAML Authentication - Integrates with SAML 2.0 identity providers to manage authentication and automate account provisioning.
• Single Sign-On Integrations - Connects OIDC identity providers to manage user authentication and handle team membership.
• Causal Relationship Modeling - Implements non-hierarchical linking between spans to model complex asynchronous causal interactions in distributed systems.
• Telemetry Data Suppression - Protects private information by excluding specific URL patterns or sanitizing sensitive request headers in telemetry.
• Span Error Marking - Links application exceptions to active trace spans by setting error statuses for faster root-cause analysis.
• Span Failure Annotation - Marks trace spans as failed when exceptions occur, associating error details with the specific request context.
• Log Pattern Normalization - Uses Grok-style patterns to normalize noisy logs and identify recurring issues through fingerprinting.
• Trace Exception Recording - Records detailed exception data within trace spans to simplify root-cause analysis during distributed request failures.
• Identity Federation - Integrates with external identity providers like Google and Okta via OIDC to manage authentication and team access.
• Next.js Integrations - Automatically captures spans for HTTP requests, server actions, and database queries specifically for Next.js applications.
• Automated Lifecycle Management - Provides AI assistants that automate the creation and configuration of monitoring dashboards via natural language and YAML templates.
• Alert Notification Systems - Configures email notifications that trigger when specific monitoring conditions or thresholds are met.
• Notification Frequency Control - Prevents alert fatigue using adaptive intervals to limit the frequency of repeated notifications.
• Alert Routing - Routes system alerts to external destinations like Slack or PagerDuty based on configurable filters.
• Application Tracing Libraries - Automatically captures execution spans for web framework events and user interactions.
• Java Integrations - Provides specific auto-instrumentation packages for Java Virtual Machine and frameworks like Spring MVC and JDBC.
• Java Log Capture - Captures structured logs from Java applications via instrumentation agents or manual appenders.
• Database Instrumentation - Automatically instruments database interactions to visualize query performance and latency within distributed traces.
• Database Performance Monitors - Tracks database-specific details, including SQL statements and operation types, for detailed performance analysis.
• Deployment Event Markers - Adds named markers to performance charts via API to correlate deployments and incidents with metric fluctuations.
• eBPF-Based Tracing - Captures distributed traces and metrics for any language using kernel-level eBPF auto-instrumentation.
• Go Binary Tracing - Captures traces and metrics from Go binaries at the kernel level using eBPF without needing code changes.
• AWS Lambda Integrations - Instruments functions using a Lambda layer and Collector sidecar extension.
• PHP Language Runtimes - Provides automatic instrumentation for PHP applications to collect distributed traces, metrics, and logs.
• End-to-End Message Tracing - Links producers and consumers across message brokers into a single trace to visualize the full message lifecycle.
• Log Error Alerting - Triggers immediate notifications when logs match predefined message patterns or reach critical severity levels.
• Error Tracking - Records exceptions and error details within web frameworks to analyze user experience impact.
• Exception Aggregations - Aggregates exceptions by type and message to identify recurring issues and track frequency.
• External API Instrumentation - Tracks outgoing HTTP requests to external services to measure external dependency latency and reliability.
• Front-to-Back Trace Correlation - Links browser-side operations with backend API calls to trace a request's entire path.
• Grafana Integrations - Phoenix exposes Prometheus and Tempo compatible endpoints for querying metrics and traces in Grafana.
• HTTP Log Ingestion - Implements an HTTP sink to collect log data transmitted from external agents via HTTP requests.
• Kubernetes Metrics Analysis - Retrieves and filters performance data from Kubernetes-native metric stores for nodes and pods.
• Latency Monitoring - Ranks API endpoints by response time and calculates percentiles to troubleshoot performance bottlenecks.
• Log Transformation Pipelines - Modifies incoming logs by moving fields, adding environment metadata, or parsing structured data during ingestion.
• Log Pattern Aggregation - Groups similar log records by pattern to visualize frequency and occurrence trends over time.
• Log Pattern Alerting - Triggers immediate alerts when logs match specific patterns, exception types, or severity levels.
• Span Event Recording - Records log messages and severity levels as events within trace spans for high-context debugging.
• Log Analysis - Visualizes log frequency and patterns over time using histograms and line charts.
• Metric Relabeling - Renames, transforms, or extracts substrings from metric labels using string functions and regular expressions during ingestion.
• Metric Tagging Utilities - Associates service names, environments, and deployment details as tags on all traces and metrics for correct grouping.
• Telemetry Transformation Rules - Modifies ingested spans and logs using YAML rules to rename attributes and normalize data.
• Automatic Template Deployment - Automatically installs pre-built visualization templates when matching metrics are detected in the telemetry stream.
• Metric Dimensional Attributes - Attaches key-value metadata to measurements for granular filtering of metrics by attributes like region or user type.
• Prometheus-Compatible Data Sources - Connects to Grafana as a Prometheus-compatible data source to visualize metrics.
• Alert-Dashboard Integration - Unifies alerting logic and visual monitoring by linking specific metric monitors directly to dashboards.
• Observability Data Filters - Filters spans and logs using attribute-based conditions or text pattern matching to isolate specific datasets.
• Business Operation Spans - Allows the creation of manual spans and custom attributes to track specific business-critical operations.
• Log Forwarders - Integrates with log forwarders like Vector and FluentBit to gather and transform logs for centralized storage.
• Metric and Performance Monitors - Monitors span durations, error rates, and failed request counts using metric monitors.
• Infrastructure Metrics - Gathers hardware and operating system metrics like CPU, memory, and network usage from hosts and middleware.
• Kubernetes Monitors - Tracks resource utilization, performance, and health of nodes, pods, and containers within Kubernetes clusters.
• Monitoring Infrastructure Automation - Automates the deployment, scaling, and orchestration of monitoring backends using Kubernetes, Helm, and version-controlled configurations.
• Trace-Derived Metric Aggregations - Calculates summaries like averages and percentiles across grouped spans to derive performance metrics.
• Cumulative Counters - Provides cumulative counters to track the total running sum of occurrences or active resource counts over time.
• eBPF-Based Collection - Intercepts network system calls at the kernel level to generate traces and metrics without code changes.
• In-Transit Processing - Performs tail-based sampling and attribute redaction by routing data through a middle-man collector.
• Runtime Language Instrumentation - Automatically tracks requests and database queries in Node.js applications by patching modules at runtime.
• Python Language Runtimes - Injects tracing logic into Python applications at runtime using a wrapper utility for supported libraries.
• Custom Span Timing - Measures detailed execution timing for specific service operations through the creation of custom spans.
• Manual Span Definition - Supports the manual definition and logging of specific code blocks as custom execution spans for performance measurement.
• Metadata Annotations - Provides the ability to attach custom key-value attributes and events to spans for deeper operational context.
• Workload Isolation with Projects - Separates data and users by project with dedicated resource quotas and custom branding for multi-tenancy.
• Trace Linking - Creates associations between spans in different traces to link disparate operations.
• Performance Metrics - Tracks server performance using histograms and gauges to monitor request duration and body size.
• PostgreSQL Performance Monitoring - Collects connection counts, query throughput, and replication lag to monitor PostgreSQL database performance.
• Request Tracing - Captures and tracks the flow of incoming HTTP requests, including duration, status codes, and paths.
• Request Trace Customization - Allows modification of span names, addition of custom attributes, and filtering of specific endpoints from being traced.
• Resource Visualization Dashboards - Monitors container performance using specialized time series charts and heatmaps.
• System Performance Monitors - Provides utilities to track and display real-time hardware metrics and resource utilization from the operating system.
• Telemetry Exporters - Provides the ability to forward collected telemetry data to external platforms including Jaeger, Prometheus, and Zipkin.
• Telemetry Resource Attributes - Labels telemetry data with service names and versions to identify the source of the data.
• Telemetry Sampling Strategies - Drops specific data points or samples successful requests to reduce noise and manage storage costs.
• Time-Series Event Overlay - Correlates performance fluctuations with system changes by overlaying deployment and incident markers on time-series charts.
• Database Query Tracing - Automatically captures SQL statements and execution time to monitor database performance within trace contexts.
• Attribute-Based Sampling - Defines custom sampling rates based on service names, endpoint paths, or user IDs.
• Statistical Distribution Analysis - Groups values into buckets using histograms to measure the statistical distributions of latencies or response sizes.
• Log Pattern Detection - Watches logs for specific severity levels or exception types to trigger automated notifications.
• Cost and Token Trackers - Tracks token consumption and computes costs per session and model to monitor generative AI operational expenses.
• Value Distribution Histograms - Groups values into buckets to analyze statistical distributions of request latencies or response sizes.
• Tail-Based Sampling - Filters and selects specific traces for storage after request completion to prioritize errors and high-latency events.
• Dashboard Layout Templates - Uses YAML files to define and share standardized dashboard layouts and alert monitors across different environments.
• Dashboard Layouts - Provides a declarative way to define monitoring dashboard layouts and visualization types using structured YAML files.
• Distributed Tracing - Unified monitoring tool for distributed tracing, metrics, and logs.
• Monitoring and Alerting - APM tool with OpenTelemetry support.
• Observability - Application monitoring and observability platform.
• Observability and Monitoring - APM platform with distributed tracing and metrics.

Istoric stele