GreptimeTeam/greptimedb

Features

• Unified Observability SQL Querying - Stores and queries metrics, logs, and traces together in a single columnar database with SQL and PromQL.
• Observability Signal Unifications - Stores metrics, logs, and traces as timestamped wide events in a single columnar engine for cross-signal JOIN queries.
• Unified Observability Data Models - Stores and queries metrics, logs, and traces together in a single database with SQL and PromQL.
• Compute-Storage Separation - Separates compute nodes from durable object storage for independent scaling of each layer.
• Kubernetes Operators - Ships a Kubernetes operator for automating the lifecycle of time-series database clusters.
• Columnar Storage Engines - Stores time-series data in a columnar format optimized for analytical queries and cost efficiency.
• LSMT-Based Columnar Engines - Stores time-series data in a columnar format using a Log-structured Merge-tree architecture.
• Time Series Data Storage - Organizes data into tables with a required timestamp column, supporting auto-schema inference and distributed partitioning.
• Log-Structured Merge-Tree Implementations - Stores time-series data using a Log-structured Merge-tree architecture for high-throughput writes and efficient queries.
• OTLP Ingestion - Accepts OpenTelemetry protocol data for metrics, traces, and logs via OTLP.
• Remote Write Protocols - GreptimeDB accepts metrics from a Prometheus instance by configuring it to forward data through the remote write protocol.
• Real-Time Data Processors - GreptimeDB processes incoming data incrementally and continuously, updating results as new data arrives for immediate analytics.
• Log Pipeline Processors - GreptimeDB processes raw data in real-time with configurable pipelines for parsing, extraction, and type conversion.
• Time-Series Data Abstractions - Writes metrics, logs, or traces to a time-series database using a table abstraction with automatic schema generation.
• Table Schemas - Defines table schemas with Tag, Timestamp, and Field columns for time-series data.
• Time-Series Schema Designs - Defines columns, primary keys, and indexes optimized for time-series data.
• Continuous Aggregation Flows - GreptimeDB defines a persistent SQL query that incrementally aggregates streaming data and writes results to a sink table.
• Flownode-Based Aggregations - GreptimeDB runs streaming and materialized view computations on ingested data via an optional Flownode component.
• Distributed Query Processing - Splits a query into sub-queries, dispatches them to relevant data nodes, and merges partial results into a single response.
• Time-Window Aggregations - Partitions time-series data into fixed intervals for grouped computation using a date_bin function.
• Cloud Object Storage - Persists time-series data in remote object stores like AWS S3 for scalable, cost-effective storage.
• High-Volume Tabular Querying - Uses a columnar engine with fulltext, inverted, and skipping indexes for high-concurrency point queries and analytical scans.
• Horizontal Scaling - Distributes data across object storage and adds nodes without manual rebalancing.
• Decoupled Compute and Storage Scaling - Scales compute and storage independently across a cluster for flexible resource optimization.
• Elastic Kubernetes Scaling - Scales compute and storage independently on Kubernetes with automatic failover and no data loss.
• HTTP Query Protocols - Sends SQL queries over HTTP using a RESTful endpoint and returns results in JSON format.
• Object Storage Persistence - Persists primary data to S3, GCS, or Azure Blob with a tiered memory-and-disk cache.
• PromQL-Compatible Engines - Runs PromQL range queries through a dedicated endpoint and returns results in JSON format.
• Query Languages - Accepts SQL and PromQL queries to explore and filter time series data directly from the dashboard interface.
• Real-Time Data Aggregators - Continuously computes aggregated metrics from raw events using a streaming pipeline without pre-processing.
• Schema-Agnostic Ingestion - Creates tables and adds columns on the fly as data arrives, eliminating the need to define schemas beforehand.
• SQL-Based Table Management - Manages tables using standard SQL with time zone support.
• Storage-Compute Architectures - Separates compute nodes from durable object storage for independent scaling.
• Time-Series Schema Writes - Constructs a table object with tag, timestamp, and field columns, then inserts rows to write structured time-series data.
• Time-Series Aggregations - Calculates sum, average, maximum, minimum, and count over numeric fields in time-series data.
• Time Series Databases - Scales horizontally with decoupled compute and storage for time-series workloads.
• Kubernetes Deployments - Deploys and manages a horizontally scalable time-series database cluster on Kubernetes.
• Time Series Indexing - Uses inverted, skipping, and full-text indexes to speed up query performance on time-series data.
• Time Index Definitions - Designates a timestamp column as the primary temporal key for time-series operations.
• Time-Series Insertions - Adds rows of metrics data into a table using standard SQL INSERT statements with or without explicit column names.
• Time-Series Table Creations - Creates time-series tables with time index and tag columns for efficient storage.
• Time-Series SQL Querying - Queries observability data across metrics, logs, and traces using SQL and language-specific clients.
• Wide Event Stores - Stores high-cardinality, context-rich event records capturing complete application state in a single row.
• Write-Ahead Logging - Records every data change to a durable log before applying it to prevent data loss.
• Authentication Configurations - GreptimeDB enables and configures authentication to secure database access before deployment.
• Multi-Protocol Data Ingesters - Accepts metrics, logs, and traces through OpenTelemetry, Prometheus, InfluxDB, and Kafka protocols.
• SQL Query Executions - Accepts SQL statements over HTTP and returns query results as structured JSON.
• Database - Uses a Kubernetes operator to automate the creation, scaling, and teardown of database cluster components.
• Cluster Scaling Orchestrators - Dynamically adjusts cluster capacity by adding or removing nodes without downtime.
• Component Scaling - Adjusts replica counts for datanodes and frontends to handle changing workloads.
• Edge-to-Cloud Deployments - Runs as a standalone binary or a cloud-native cluster with modular components for edge-to-cloud deployment.
• Helm Chart Cluster Installation - Installs and configures a full database cluster on Kubernetes using a single Helm chart.
• Standalone or Cluster Deployments - Runs as a single-node instance or a distributed cluster to match scale and availability requirements.
• Database Cluster Deployments - Automates provisioning and lifecycle of a time-series database cluster on Kubernetes using custom resource definitions.
• Database Cluster Deployments - Creates a database cluster on Kubernetes with configurable replicas, storage, and artifact sources.
• Time-Series Database Deployments - Installs and manages a time-series database cluster on Kubernetes using Helm charts.
• Kubernetes Operators - Deploys and manages time-series database clusters on Kubernetes using custom resources.
• Log Processing Pipelines - Applies configurable pipelines to extract structured fields from raw log lines before insertion.
• Deployment Mode Selection - Runs as a single binary for development or as independently scalable components for production.
• Static Credential Authentications - GreptimeDB loads user accounts and passwords from a configuration file at startup, granting each user a specified permission level.
• Initial User Account Seeds - GreptimeDB loads predefined accounts from a password file at startup to bootstrap authentication.
• Read-Write Permission Modes - GreptimeDB enables user authentication and assigns readwrite, readonly, or writeonly permissions to control access to the database.
• Log Parsing - GreptimeDB applies a sequence of built-in processors to parse, transform, and clean log fields before storage.
• Write-Only Access Modes - GreptimeDB assigns read-write, read-only, or write-only access to each user, controlling what operations they can perform.
• Log Ingestion - Writes unparsed log messages into a table with a manual timestamp, bypassing any pipeline processing.
• Log Collector Integrations - Accepts log data from standard collectors such as Vector, Fluent Bit, and Kafka.
• Log Transformation Pipelines - Applies configurable pipelines to parse, transform, and enrich raw log lines during ingestion.
• OpenTelemetry Ingestion - Consumes OpenTelemetry metrics natively through the OTLP/HTTP protocol.
• OTLP Log Ingestion - Accepts OTLP/HTTP log payloads and maps them to tables with optional custom pipelines and attribute extraction.
• Trace Ingestion - Accepts OTLP/HTTP trace payloads and maps each span to a row in a table.
• Trace Table Storage - Automatically maps OpenTelemetry trace fields to a table schema, flattening attributes into columns.
• Unified Observability Ingestion - Ingests metrics, logs, and traces through a unified OpenTelemetry backend, replacing dedicated stores.
• Prometheus-Compatible Backends - Serves as a long-term backend for Prometheus by accepting remote write requests and persisting metrics.
• Metric Time-Series Graphs - GreptimeDB retrieves numerical values with timestamps for visualizing metric trends over time in a Grafana panel.
• Prometheus Exporters - GreptimeDB publishes metrics in Prometheus format so an existing Prometheus instance can scrape and alert on them.
• Trace Querying - Searches and visualizes trace data by trace ID, span ID, service name, and span attributes.
• Cross-Signal Correlations - Correlates metrics, logs, and traces in one SQL query without switching between separate systems.
• SQL-Based Trace Queries - Exposes trace data in relational tables queryable with standard SQL over MySQL, PostgreSQL, or HTTP protocols.
• Read-Only Database Querying - Enables AI assistants to execute SQL, TQL, and RANGE queries with read-only enforcement and data masking.
• Database Region Operations - Provides region-level operations including viewing distribution, flushing, compacting, and migrating regions.
• Region Recovery from Failures - Activates a safety mode that lets operators manually restore a cluster when datanodes fail.
• Decoupled WAL Region Recovery - Decouples WAL from datanodes to enable region migration without local log replay after failures.
• Time-Series Downsamplers - Reduces data volume by applying operations like average pooling to stored time-series data for efficient analysis.
• Log Tag Filters - GreptimeDB filters log rows using indexed tag columns such as statuscode and httpmethod for fast retrieval.
• Arrow-Encoded Bulk Writes - Aggregates multiple tables and sends them in a single gRPC request using Arrow IPC.
• WAL-Based Standby Replication - Supports hot standby and region migration via WAL stream subscription for high availability.
• High-Cardinality Data Handlers - Distributes data across shards and uses a flat storage format to maintain performance with millions of unique series.
• Cluster Load Balancing - Automatically moves regions from overloaded datanodes to underloaded ones to balance write load.
• Common Table Expressions - Defines a temporary named result set within a SQL statement to simplify complex queries and reuse subquery logic.
• Database-Level Configurations - Adjusts compaction strategy parameters at the database level, affecting all tables without their own settings.
• Data Compression Algorithms - Reduces original data volume to about one-eighth its size through an efficient compaction mechanism.
• Adaptive Column Compressions - Selects optimal compression algorithms per column based on data statistics.
• Write Compression - Applies Zstd compression to data before sending to reduce network bandwidth.
• Batch Table Ingesters - Sends multiple rows in a single request to improve ingestion throughput with configurable batch sizes.
• Multi-Table Batch Writes - Sends data for several tables in a single asynchronous request to improve throughput.
• Multi-Provider Object Storage - Persists data to local filesystem or multiple cloud object storage providers.
• Storage Compaction Utilities - Merges SST files across time windows using configurable compaction strategies to reduce storage overhead.
• Manual Compactions - Runs compaction on a specified table on demand using an SQL command with optional window strategy.
• Time-Windowed SST Compactions - Groups SST files into time windows and merges overlapping runs to reduce read/write amplification.
• Metadata-Driven Data Skipping - Maintains metadata about value ranges per data block, allowing the query engine to skip blocks that cannot contain matching rows.
• Database Backup Restoration - Creates full or incremental snapshots of databases or tables and restores a cluster from that backup.
• Retention Policies - Configures time-to-live rules independently for each table or measurement to control data lifecycle.
• Configurations - Controls how OTLP metrics are translated, which attributes are promoted, and whether scope attributes are persisted via HTTP headers.
• HTTP - Interacts with the database through HTTP APIs for data ingestion, authentication, health checks, and SQL queries.
• gRPC SDK Ingestion Libraries - Writes data programmatically using client libraries in multiple languages for high-performance ingestion.
• Data Pipelines - Provides CRUD operations for pipeline definitions that transform incoming data before storage.
• Log Ingestion APIs - Accepts Loki push requests in protobuf or JSON format for log ingestion.
• Data Querying - Retrieves non-time-series data as a table by selecting columns and applying filter conditions.
• Numeric Range Filters - GreptimeDB filters records where a field falls within a specified numeric or date range.
• Data Retention Policies - Sets or removes the default time-to-live for data in a database, causing expired data to be deleted asynchronously.
• Time-Series Visualizers - Ships an embedded web dashboard for browsing metrics, logs, and traces after startup.
• Database Backups - Creates a copy of a database using the COPY DATABASE command to guard against data loss.
• Elasticsearch Protocol Ingestion - Accepts log data through the Elasticsearch protocol for direct ingestion from existing pipelines.
• MySQL Connectors - Connects using a standard MySQL client driver with configurable host, port, and authentication.
• Active Cluster Failovers - Switches traffic between two live clusters so the system stays available when one cluster becomes unreachable.
• Table Metadata Inspection - Retrieves full table schema, routing, and partition details by table ID or name.
• Full-Text Indexes on Log Columns - GreptimeDB enables term-based search on unstructured text columns by tokenizing and indexing the content.
• Local WAL Configurations - Provides tunable local WAL storage engine settings for durability and performance.
• WAL Backend Selections - Offers a choice between embedded and external (Kafka) WAL backends with different trade-offs.
• Remote WAL Configurations - Connects to a Kafka cluster for remote write-ahead logging to enhance durability.
• Remote WAL Enabling - Streams write-ahead logs to an external Kafka cluster for enhanced durability.
• Database Namespace Creations - Creates a logical namespace for tables with an optional default Time-To-Live inherited by all child tables.
• Continuous Aggregate Definitions - Executes ongoing tasks that read source table changes and write computed results to sink tables.
• Flownode-Based Aggregations - Runs streaming and materialized view computations via an optional Flownode component.
• Disaster Recovery Solutions - Distributes metadata and data across multiple regions and availability zones for service continuity.
• Disaster Recovery Strategies - Applies strategies to protect data and ensure business continuity after failures.
• Pushdown-Optimized Executions - Splits queries into sub-queries and propagates runtime filters remotely to prune data earlier.
• Data Partitioning - Splits a table into multiple partitions distributed across nodes to scale throughput.
• Trace Routing - Directs Jaeger API queries to user-specified trace tables via HTTP headers, supporting multi-table trace storage.
• Primary Keys - Selects columns that order data on disk and identify time series for deduplication and efficient scans.
• Time-Windowed Writes - Groups ingested rows by timestamp windows to avoid out-of-order splits that degrade performance.
• Metric Table Consolidations - Consolidates many small metric tables into wide physical tables to reduce storage overhead.
• Full Text Search - Performs keyword searches on log messages using a full-text index and the @@ operator.
• Large Dataset Streaming - Sends a continuous stream of rows for importing high-volume historical data without blocking.
• Bulk Data Ingestion - Ingests high volumes of time-series data using off-heap memory and binary serialization.
• Elasticsearch Bulk API Ingestion - Accepts NDJSON data through the Elasticsearch _bulk HTTP endpoint, mapping each index to a table.
• Metadata-Based Write Routings - Resolves table and region metadata from a control plane and forwards write requests to the appropriate data nodes.
• Backend Configurations - Configures cloud object storage services like AWS S3 or Azure Blob Storage as the data backend.
• Phrase Sequence Matching - GreptimeDB matches an exact phrase in a text field, converting to a LIKE query for text types.
• PostgreSQL Foreign Data Wrappers - Exposes tables as foreign tables in PostgreSQL for cross-database joins and queries.
• PostgreSQL Protocol Compatibility - Connects using the standard PostgreSQL wire protocol on port 4003 for familiar PostgreSQL clients.
• Data Ingestion - GreptimeDB connects via the PostgreSQL protocol to manage tables, ingest and query data, and handle time zones.
• Query Condition Builders - GreptimeDB combines multiple query conditions using AND and OR logic in a single request.
• Continuous PromQL Evaluations - Evaluates PromQL functions like rate() on streaming data at scheduled intervals, writing results to a sink table for real-time monitoring.
• Embedded PromQL in SQL - Embeds PromQL expressions inside SQL queries using TQL to combine the analytical power of both languages.
• Query Performance Tuning - Adjusts configuration and table schema design to optimize query and ingestion efficiency.
• Read Replicas - Creates read-only instances of data to distribute read workloads and improve query performance.
• Read Replica Routing Preferences - Directs read requests to follower regions to offload write replicas and improve query scalability.
• Client Libraries - Ships official gRPC client libraries for Go, Java, Rust, .NET, Erlang, and TypeScript.
• Region Leadership Failover - Automatically transfers region leadership to healthy replicas with configurable data loss tolerance.
• Helm-Based Topology Configurations - Sets component replica counts and cluster layout through a Helm values file.
• Row Insertions - GreptimeDB executes SQL statements to create tables and insert rows directly into the database.
• Prefix Searches - GreptimeDB matches text fields starting with a specified prefix by converting to a LIKE query.
• Elasticsearch REST APIs - Accepts Elasticsearch QueryDSL syntax and returns results in Elasticsearch API format.
• Multi-term Search Processors - GreptimeDB finds logs containing any of several specified terms by joining matches_term conditions with OR operators.
• Negative Search Terms - GreptimeDB filters out logs that match a specified term while keeping those that match another, using NOT with matches_term.
• Term Matching Queries - GreptimeDB matches one or more terms in a text field using a full-text search query.
• Local Query Execution on Any Node - Runs queries locally on the connected node so traffic continues if another node fails.
• Continuous Aggregate Functions - Processes streaming data with continuous aggregation flows to produce downsampled results in real time.
• Standalone Instance Recoveries - Restores a stateless standalone database from remote WAL and object storage after a disaster.
• Automatic Metadata Stampings - Automatically records signal type and source metadata from incoming data streams.
• Table Storage Option Modifications - Adjusts table-level storage settings like retention, append mode, and compaction.
• Rate-Limited Stream Writes - Maintains a persistent connection for continuous ingestion while capping the rate.
• Kafka Stream Ingestion - Transports observability data from Kafka topics into the database using Vector.
• JSON Log Ingestors - Reads JSON-formatted log messages from Kafka and creates structured tables automatically.
• Metric Ingestors - Reads metrics formatted in InfluxDB line protocol from Kafka topics and ingests them.
• Plain Text Log Ingestors - Reads plain-text log messages from Kafka and parses them into structured data using custom pipelines.
• Table Deletions - Permanently removes tables and all their data from the database.
• Column Indexing - Enables inverted, fulltext, and skipping indexes on columns to accelerate queries.
• Horizontal Table Partitionings - Splits tables horizontally across nodes to scale ingestion and query throughput.
• Virtual Table Definitions - Creates named SQL views that wrap queries for reuse like real tables.
• Virtual Table Querying - Creates virtual tables from SQL result sets that dynamically retrieve data on each query.
• Observability Metadata Annotations - Ships a DDL syntax for declaring observability concepts and lineage directly in CREATE TABLE statements.
• Physical Table Definitions - Ships a metric-engine that lets users define physical tables with custom column types and index settings.
• Partitioned Physical Tables - Distributes metric-engine physical tables across datanodes using custom partition rules on labels.
• Observability Data Exploration - Integrates with the Model Context Protocol so AI assistants can explore and query metrics, logs, and traces.
• Storage Cost Reductions - Stores data on cloud object storage with columnar compression, achieving up to 50x cost efficiency.
• Database Cluster Scaling - Adjusts the number of replicas in a database cluster by modifying a single field in the custom resource.
• Edge Database Deployments - Deploys database instances close to data sources to minimize latency and process data in real-time.
• Cross-Region Cluster Recoveries - Spans a single cluster across three regions with cross-region WAL and object storage for zero-RPO recovery.
• Kubernetes Database Upgrades - Rolls out new database versions on Kubernetes with minimal downtime.
• Alertmanager Alert Forwarders - Pushes firing and resolved alerts to Prometheus Alertmanager using a fully compatible payload.
• Standalone Database Instances - Provisions a single-instance time-series database on Kubernetes using a dedicated custom resource definition.
• Conditional Log Routings - GreptimeDB forwards log data to different pipelines and tables based on the value of a specified field.
• Synchronous Dual-Node Failover - Provides synchronous replication between two nodes for zero-data-loss failover.
• Version Upgrades - Provides a guided procedure for updating the database to a newer release while preserving data.
• Per-Table Parallelism Controls - Sets the number of concurrent compaction workers per table to speed up file merging.
• Telegraf Integrations - GreptimeDB collects system and application metrics with Telegraf and forwards them to a time-series database using the InfluxDB line protocol.
• Distributed Tracing - Captures and exports distributed tracing data for end-to-end request visibility.
• Log Querying - Searches log entries via a dedicated HTTP endpoint with time range and string filter criteria.
• Database AI Access Restrictions - GreptimeDB blocks destructive SQL statements and masks sensitive columns by pattern, with optional audit logging of every tool invocation.
• Audit Logging - GreptimeDB enables and customizes audit logging through a plugin configuration to capture specific database activities.
• Table-Level Access Controls - GreptimeDB controls table-level access within specific databases using exact matches or regular expressions for fine-grained permissions.
• Role-Based Access Control - GreptimeDB assigns global privileges to users controlling operations like SELECT and INSERT through role-based access control.
• View-Based Data Masking - Defines views that expose only specific columns and rows to restrict data access.
• Pluggable Cluster Metadata Stores - Stores cluster metadata in etcd, MySQL, or PostgreSQL for production reliability.
• Log Event Filters - GreptimeDB applies string-matching filters like "contains" on text columns to narrow log results to matching entries.
• Telemetry Routing - GreptimeDB sends traces, logs, and metrics through separate exporters to isolate data and apply custom processing per signal type.
• Cluster Health Monitoring - Deploys a dedicated instance alongside the cluster to collect and store metrics, logs, and traces for health observation.
• Cluster Monitoring - Tracks CPU, memory, disk I/O, and network bandwidth across cluster nodes to detect capacity issues.
• HTTP Header Log Routers - Directs ingested log entries to specified databases and tables by setting custom HTTP headers on push requests.
• Database Operation Auditing - GreptimeDB records all database operations with configurable detail, enabling security review and compliance tracking.
• Global Prometheus Querying - Provides standard Prometheus HTTP endpoints for querying and exploring metric data.
• HTTP Log Ingestion - Accepts log data through Fluent Bit's HTTP output plugin with optional pipeline processing.
• Elasticsearch Protocol - Accepts log data through the Elasticsearch ingestion protocol for direct log collection from compatible agents.
• Named Pipeline Ingestion - Sends log data to an HTTP endpoint referencing a named pipeline for automatic parsing.
• Pipeline Lifecycle Managements - GreptimeDB removes a named pipeline and all its versions from the database through an HTTP interface.
• Log Query Engines - GreptimeDB retrieves log entries with timestamp and message columns for display and analysis in a Grafana panel.
• SQL-Based Log Analysis - Retrieves and filters log entries using standard SQL, including full-text search on parsed message columns.
• Automated Log Analyzers - Ingests massive volumes of log data and enables querying for insights within minutes.
• Batch Metric Ingestion - Accumulates incoming rows and flushes them in larger batches to the metric engine for improved write throughput.
• InfluxDB Metric Ingestors - Accepts time-series data formatted as InfluxDB Line Protocol via an HTTP endpoint.
• InfluxDB Client Library Support - Supports writing time-series data using official InfluxDB client libraries by pointing them at the compatible HTTP endpoint.
• OTLP Metric Ingestion - GreptimeDB sends OpenTelemetry metrics to a backend through an OTLP/HTTP exporter with basic authentication.
• Grafana Dashboard Configurations - Provides pre-built Grafana dashboards and configuration steps for database metrics.
• Cluster Dashboards - Provides pre-built Grafana dashboards for cluster health and performance data.
• Database Data Sources - Connects Grafana to the database via a dedicated plugin, Prometheus, or MySQL protocol.
• Prometheus-Compatible Data Sources - Registers as a Prometheus-compatible data source in Grafana for visualization and alerting.
• Slow Query Analyzers - Lists long-running SQL and PromQL queries with execution times and provides execution plan analysis.
• Cluster Monitoring Systems - Shows pre-built monitoring panels for ingestion rates, query latency, and resource utilization.
• Storage Performance Metrics - Exposes histograms and counters for storage engine read/write stages, cache hits, and flush durations.
• SQL-Based Alerting Rules - Evaluates SQL-based rules on time-series data at intervals and sends notifications via webhooks.
• Prometheus Cluster Management - GreptimeDB creates a Prometheus PodMonitor to collect and scrape metrics from the deployed database cluster automatically.
• PodMonitor-Based Metric Collection - GreptimeDB collects time-series metrics from a GreptimeDB cluster into an existing Prometheus instance using automatically created PodMonitor resources.
• Prometheus-Based Metric Exporters - GreptimeDB serves metrics in Prometheus format for collection by monitoring systems.
• Automatic Metric-to-Table Mappings - Automatically creates a table per metric name with labels as tag columns and values as field columns.
• System Table Slow Query Logs - Stores slow query records in a dedicated system table for structured analysis and debugging.
• Time-Window Filtering - Restricts query results to rows within a specified time range using timestamp comparisons.
• Jaeger-Compatible Trace APIs - Provides a Jaeger-compatible API endpoint so existing Jaeger frontends can query stored trace data.
• Vector Metric Ingestions - GreptimeDB sinks telemetry data from Vector into the database for complex data pipeline processing.
• Vector Observability Pipeline Integrations - GreptimeDB streams observability data from Vector into a time-series database using its native sink integration.
• Hot Spot Resolutions - Provides a mechanism to repartition tables via Helm Chart configuration to resolve data hot spots.
• Database Systems - Cloud-native distributed time-series database.
• Observability Backends - Unified database for storing metrics, logs, and traces.

Star history