DOCSEARCHbyAlgolia
Submit Docs

Parseable Observability Platform

website·Indexed 34 days ago

https://www.parseable.com/docs

A purpose-built telemetry datalake for monitoring metrics, events, and logs (MELT data). It features a PostgreSQL-compatible SQL query interface, support for high-availability deployments, and specialized capabilities for agentic observability, including tracking tool calls for AI agents and LLM-powered applications. The platform offers various editions, including an OSS version and an Enterprise edition, with integrations for Prometheus Remote Write, eBPF via Tetragon, and a dedicated MCP Server.

Tokens
205.7K
Snippets
734
Records
1.2K
Agent score
72%

What's inside Parseable

  1. Overview of Parseable Agent Observability

    Parseable Agent Observability allows developers to debug complex agent executions by providing a full view of the execution path, including prompts, model selection, tool calls, token usage, and intermediate steps. It is built on the OpenTelemetry GenAI semantic conventions, ensuring a standardized shape for telemetry data. It is framework-agnostic; any instrumentation path that sends compatible OpenTelemetry trace data can be used.

  2. Overview of Parseable ingestor architecture for Amazon MSK on EKS

    Parseable ingestors running on EKS can consume JSON records directly from Amazon MSK without intermediate components. The architecture utilizes EKS Pod Identity to provide temporary AWS credentials, which Parseable uses to sign short-lived OAuth bearer tokens for MSK authentication via SASL_SSL on port 9098.

    Key workflow steps:

    1. EKS injects Pod Identity credentials into pods via a Kubernetes ServiceAccount.
    2. Parseable resolves credentials using the AWS SDK default chain.
    3. Parseable generates an AWS MSK IAM token for the configured region.
    4. librdkafka connects using SASL_SSL and OAUTHBEARER.
    5. MSK distributes topic partitions across ingestors in a shared consumer group.
    6. Valid JSON records are batched, and the Kafka topic name is used as the Parseable stream name.
    7. Processed data is written to an S3-compatible object store.

  3. Overview of LiteLLM SDK observability with Parseable

    The LiteLLM Python SDK allows applications to call multiple LLM providers (OpenAI, Anthropic, Gemini, etc.) through a single interface. When integrated with Parseable via OpenTelemetry, it provides three types of telemetry:

    • Traces: Show individual model calls and their position within the application flow.
    • Logs: Show GenAI events emitted by the LiteLLM OpenTelemetry integration.
    • Metrics: Provide histograms for request duration, token usage, cost, and streaming latency.

  4. Overview of Parseable Slackbot

    The Parseable Slackbot integrates Parseable investigation capabilities directly into Slack conversations. It allows users to query logs, metrics, traces, and alerts using @parseable without leaving Slack. The bot works via the Parseable MCP (Model Context Protocol) path, where Slack acts as the interface, MCP provides the toolset, and Parseable provides the data. It is compatible with Parseable OSS, Cloud, and Enterprise editions.

  5. Overview of Parseable AI-native observability features

    Parseable provides several AI-native capabilities to accelerate observability workflows and reduce mean time to resolution (MTTR):

    • Keystone: A system of AI agents that allows users to ask questions about telemetry data using natural language.
    • Dataset Summarization: AI-powered summaries of datasets used to identify patterns, anomalies, and potential issues.
    • Text to SQL: An assistant that generates SQL queries from plain English descriptions, explains complex SQL, and fixes broken queries.

  7. Overview of Pydantic AI observability with Parseable

    Pydantic AI is a Python framework for building typed agents. It includes built-in OpenTelemetry instrumentation that allows Parseable to capture agent runs, model requests, and tool executions. A single agent run is represented as a trace with the agent span at the top, containing nested model-call and tool spans. This enables tracking of model providers, token usage, latency, and tool arguments/results.

  8. Overview of CrewAI instrumentation with Parseable

    Parseable captures CrewAI telemetry as OpenTelemetry traces. This allows developers to debug complex agentic workflows—including agent handoffs, tool calls, and retries—by inspecting the full crew run in a trace view. The integration uses OpenInference instrumentation to capture both the application workflow (CrewAI) and the underlying model calls (e.g., OpenAI).

  9. Overview of Daytona and Parseable integration

    Daytona provides isolated sandboxes for code and agent workloads. Integrating Daytona with Parseable allows developers to observe two distinct telemetry paths: SDK tracing (what the application does via the Daytona SDK) and Sandbox telemetry (what happens inside the sandbox runtime, including logs, resource metrics, and internal traces).

  10. Overview of Parseable PromQL capabilities

    Parseable Enterprise includes a built-in PromQL engine that allows users to ingest, store, and query metrics using the standard Prometheus Query Language without needing a separate Prometheus instance. It supports distributed execution in cluster mode and is compatible with Prometheus Remote Write for ingestion.

    Key capabilities include:

    • Full support for instant and range queries.
    • Over 50 PromQL functions (e.g., rate, histogram_quantile, holt_winters).
    • 12 aggregation operators (e.g., sum, avg, topk, quantile).
    • Standard binary operators for arithmetic, comparison, and set operations.
    • Cardinality analysis endpoints.

  11. Overview of Hermes Agent observability with Parseable

    The Hermes Agent can be observed using the hermes-otel plugin, which hooks into the Hermes lifecycle to export activity (agent, model, API, tool, and skill) via OpenTelemetry (OTLP/HTTP). Data is sent to Parseable across three distinct datasets: hermes-traces for traces, hermes-logs for logs, and hermes-metrics for metrics. A Parseable instance can receive this data directly without requiring an intermediate OpenTelemetry Collector.

  12. Overview of .NET telemetry ingestion to Parseable

    Parseable collects telemetry from .NET applications via the OpenTelemetry Protocol (OTLP). Signals are routed through an OpenTelemetry Collector and sent to three distinct Parseable datasets to optimize query modes: dotnet-logs for application logs, dotnet-traces for spans and HTTP calls, and dotnet-metrics for runtime and process metrics.