Skip to content

SKILL.md

Latest commit

 

History

History
380 lines (327 loc) · 21.3 KB

SKILL.md

File metadata and controls

380 lines (327 loc) · 21.3 KB
Raw
name signoz-generating-queries
description Generate, write, or run an ad-hoc query against SigNoz observability data — metrics, logs, or traces — without wrapping it in a dashboard panel or alert. Make sure to use this skill whenever the user asks "show me error rates", "query logs for timeout errors", "what's the p99 latency for the cart service", "how many requests hit the payment endpoint", "find slow traces", "errors in the last hour", or otherwise asks an exploratory question that needs live observability data — even if they don't say "query" or "search" explicitly.

Query Generate

Prerequisites

This skill calls SigNoz MCP server tools heavily (signoz_execute_builder_query, signoz_query_metrics, signoz_search_logs, signoz_search_traces, signoz_aggregate_logs, signoz_aggregate_traces, signoz_get_field_keys, signoz_get_field_values, signoz_list_metrics, signoz_list_services, signoz_get_service_top_operations, signoz_get_trace_details). Before running the workflow, confirm the signoz_* tools are available. If they are not, run signoz-mcp-setup first to initialize or repair the MCP connection. Do not fall back to raw HTTP calls or fabricate query results without the MCP tools.

When to use

Use this skill when the user asks to:

  • Query, search, or look up observability data (traces, logs, metrics)
  • Compute aggregations (error rate, p99 latency, request count, throughput)
  • Find specific log entries, traces, or metric values
  • Investigate patterns (spikes, drops, trends over time)

Do NOT use when:

  • User wants raw ClickHouse SQL for a dashboard panel (custom joins, window functions, regex over log bodies) — that's a separate dashboard-panel SQL workflow, not this skill.
  • User needs the Exceptions Explorer as an exception-specific signal — the current MCP contract has no exception query tool. Explain that limitation and offer an equivalent error-trace or error-log query only if it answers their underlying question.

Instructions

Step 1: Determine the signal type

Map the user's intent to the right signal:

User intent Signal Why
Error rate, latency, throughput, request count metrics (preferred) or traces Metrics are pre-aggregated and fastest. Use traces if the user needs per-request detail or no matching metric exists.
p50/p75/p90/p95/p99 latency metrics (histogram) or traces (aggregate on duration_nano) Prefer metrics if a histogram metric exists (e.g., signoz_latency_bucket). Fall back to trace aggregation.
Find specific log entries, error messages, stack traces logs Text search, pattern matching, severity filtering.
Find specific traces, slow requests, error spans traces Per-request detail, span attributes, duration filtering.
Infrastructure metrics (CPU, memory, disk, network) metrics Always metrics for resource utilization.
Ingestion volume (bytes or count), cost, or billing usage metrics with source=meter (Cost Meter) signoz.meter.* ingestion metrics (logs/spans/datapoints by count and bytes) live only in the meter store; bytes are unavailable on the raw signals. Dollar cost is not a metric — derive it from volume × per-unit price (see Step 2). groupBy/filter work like a normal metric, but only over the limited attribute set the meter retains (not arbitrary log/trace fields). For a count sliced by an attribute the meter doesn't carry, aggregate logs/traces directly instead.
"How many X per Y" (count/rate grouped by dimension) traces or logs (aggregate) Use signoz_aggregate_traces or signoz_aggregate_logs for grouped counts.

Traces have no unqualified full-text search; use CONTAINS against a discovered structured trace field. searchText-style body search is logs-only.

If the signal is genuinely ambiguous, ask the user before proceeding. The host application decides how the question is surfaced (e.g. a structured clarification tool or an inline <assistant_question> tag) — follow the host's UI rendering rules.

Step 2: Discover available data

Always discover before querying. Use only names returned by tools — never guess from training knowledge.

Run discovery calls in parallel where possible:

  • For metrics: Call signoz_list_metrics with a searchText substring matching the user's intent (e.g., searchText: "http", searchText: "latency"). The response includes metric type, temporality, and isMonotonic — pass these to signoz_query_metrics to avoid extra lookups. Before filtering or grouping, discover labels with signoz_get_field_keys(signal: "metrics", metricName: <discovered-name>); metric labels are not trace/log attributes (db.system, for example, is a span attribute unless discovery also returns it for metrics).

    Choose timeAggregation from the discovered metric metadata:

    Metric type Valid timeAggregation
    gauge latest, sum, avg, min, max, count, count_distinct
    monotonic counter/sum rate, increase
    non-monotonic sum avg, sum, min, max, count, count_distinct — never latest or rate
    histogram / exponential histogram omit; aggregation is automatic

  • For Cost Meter (ingestion volume, cost, billing): pass source=meter to signoz_list_metrics to discover the metrics (signoz.meter.*) — they're invisible in the default store and the set evolves, so don't hardcode it. groupBy/filters/aggregations then work like any metric, with three caveats: bytes exist only here (count is also available via direct signoz_aggregate_logs/_traces); the meter retains only a limited attribute set — discover groupable keys via signoz_get_field_keys(signal: "metrics", source: "meter"), and fall back to a direct count (no bytes) to slice by an attribute it lacks; and dollar cost is not a meter metric — the store holds only volume, so don't searchText: "cost" expecting a hit. For a cost question, query the volume metric (bytes for logs/traces, count for metric datapoints) and multiply by the per-unit price from Settings → Billing — ask the user for the price if you don't have it.

  • For traces: Call signoz_list_services to confirm the service name exists, following pagination.nextOffset while pagination.hasMore is true before declaring it missing. Optionally call signoz_get_service_top_operations for the service to find operation names. Before any attribute filter or grouping, call signoz_get_field_keys(signal: "traces").

  • For logs: Before any attribute filter or grouping, call signoz_get_field_keys(signal: "logs"); use signoz_get_field_values only after discovery to validate values.

Field keys are signal-specific: service.name may be absent on logs, while body is logs-only. Never carry a key across signals. Skip key discovery only when live output in this conversation returned it for the same signal — never for user text or memory. Use returned dot notation verbatim, not camelCase guesses such as traceID or hostname. Never assume tenant keys (org.id, orgId, organization_id, etc.); discover the actual key per signal. Call signoz_get_field_keys before signoz_get_field_values; both require signal, and values also require a non-empty discovered name.

Step 3: Choose the right tool

Use the simplest tool that answers the question:

Question type Tool When to use
Metric time series, scalar, ratio, or formula signoz_query_metrics Ordinary metrics queries, Cost Meter trends/rates, and metric ratios via formula + formulaQueries.
Cost Meter total or grouped total attribution signoz_execute_builder_query Use the discovered meter metric with raw timeAggregation: "sum"; sum complete hourly buckets. Do not use signoz_query_metrics for totals.
Log search (find matching entries) signoz_search_logs Finding specific log lines. Use searchText for body text, filter for field filters, severity for level filtering.
Trace search (find matching spans) signoz_search_traces Finding specific traces/spans. Use service, operation, error, minDuration/maxDuration shortcuts plus filter for field filters.
Log aggregation (count, avg, percentiles) signoz_aggregate_logs Plain totals, grouped counts, and top-N by one aggregation.
Trace aggregation (count, avg, percentiles) signoz_aggregate_traces Plain totals, grouped counts, and top-N by one aggregation.
Complex log/trace formula or shaping signoz_execute_builder_query Use when ratios, shaping, ordering, or cardinality control exceed the convenience tools; never hand-build a plain grouped count.

For signoz_aggregate_logs / signoz_aggregate_traces, aggregation is one bare token: count, count_distinct, avg, sum, min, max, p50, p75, p90, p95, p99, or rate. Never include parentheses or a column; put the column in aggregateOn (count and rate need none). Omit orderBy for the default aggregation-expression descending order; explicit ordering should use a groupBy key or the aggregation expression. Custom aliases or formulas require signoz_execute_builder_query.

For every signoz_execute_builder_query payload, put a positive limit and non-empty Query Builder v5 order on each builder_query and builder_formula spec. Raw requests and trace-signal requestType: trace default to 100 rows: traces order by timestamp desc, while raw logs order by timestamp desc then id desc. Scalar/time-series requests default to 100 groups ordered by __result desc for metrics/formulas or the primary aggregation desc for logs/traces. Formula results stay at 100, but every builder_query referenced by a formula uses 10000 because each component limit is applied before formula evaluation; independently top-100 inputs can drop a high-ratio group. When calculating those input bounds, inspect every formula expression, including formulas with disabled: true, and follow formula references until all builder_query leaves are found. This dependency walk sets bounds only; it does not prove deterministic formula-to-formula evaluation order, so validate the complete composite payload. Narrow filters/grouping if input cardinality can exceed 10000. This wire field is order, not dashboard editor orderBy. Time-series top-N ranks groups over the whole window, so a short-lived local spike may fall outside the returned set.

requestType decision for aggregations:

  • scalar (default): "How many?", "What is the p99?", "Which service has the most?"
  • time_series: "When did errors spike?", "How did latency change?", "Show trend"
  • If the question has ANY temporal component (spike, trend, change), use time_series

Aggregate tools accept only scalar or time_series. For builder-query envelopes passed to signoz_execute_builder_query, use only:

Signal Valid requestType
metrics time_series, scalar
traces raw, trace, scalar, time_series
logs raw, scalar, time_series

Never invent aggregate, table, timeseries, or series. This matrix does not apply to PromQL or ClickHouse SQL envelopes.

Step 4: Execute the query

  • Always include searchContext with the user's original question — it improves result relevance.
  • Respect the requested range; otherwise use 1h. Search/aggregate log and trace tools accept relative timeRange strings ("1h", "24h"; default 1h) — prefer them. Valid Unix-ms start/end override timeRange; malformed explicit timestamps return validation guidance pointing to timeRange. signoz_execute_builder_query has no relative option: its outer query requires absolute start and end as JSON integer Unix-ms or fails with missing start or end timestamp.
  • Use shortcut parameters (service, severity, operation, error) when they match the user's filters — they are simpler and less error-prone than building filter expressions.
  • Combine shortcut params with filter for additional constraints — they are ANDed together.
  • For signoz_query_metrics, pass metricType, temporality, and isMonotonic from the signoz_list_metrics response to avoid an extra auto-fetch round trip.
  • For a Cost Meter total or grouped total attribution, use signoz_execute_builder_query, not signoz_query_metrics. Pass the full tool arguments with an outer query object, Unix-millisecond start/end, requestType: "time_series", formatOptions, and variables. The builder spec keeps signal: "metrics", source: "meter", the discovered metricName and temporality, stepInterval: 3600, and raw timeAggregation: "sum" plus spaceAggregation: "sum". For grouped totals, discover the meter field with signoz_get_field_keys and copy its name, fieldDataType, fieldContext, and signal into groupBy without dropping or translating fields. Exclude datapoints marked partial: true, then sum the complete hourly buckets for each returned group.
  • signoz_query_metrics remains appropriate for a Cost Meter trend or rate that is not a total attribution. Carry source=meter, use stepInterval: 3600, use timeAggregation: increase for a volume trend, and rate only for a per-second rate.

Step 5: Handle results

Data returned:

  • Present findings as neutral observations with timestamps and values.
  • Include the time range in your response.
  • For aggregations with groupBy, highlight the top entries and mention total group count if truncated by limit.
  • For search results, summarize patterns rather than listing every entry.

No data returned — apply three-way distinction:

  1. Healthy zero: The query ran successfully but the count is zero. Say so: "No errors found for checkout-service in the last hour — error count is zero."
  2. No data in range: The field/metric exists but no data points fall in the time window. Suggest expanding: "No data in the last hour. Try a wider range?"
  3. Missing instrumentation: The metric, field, or service doesn't exist in discovery results. Say what's missing and suggest how to instrument.

Drill-down:

  • If an aggregation reveals an interesting pattern (spike, outlier service), offer to drill into individual traces or logs for that scope.
  • If a trace search returns interesting spans, offer to fetch full trace details via signoz_get_trace_details.

Guardrails

  • Discovery first: Never guess metric, field, or service names. A field is confirmed only by live output for the same signal in this conversation.
  • Supply required parameters: Never invoke tools hoping they auto-discover. signoz_aggregate_* requires aggregation; signoz_query_metrics requires a metricName from signoz_list_metrics; signoz_get_trace_details requires a traceId; signoz_get_service_top_operations requires a service from signoz_list_services. Discover first, then call.
  • Never claim root cause: Present data patterns and correlations. Write "Error rate for checkout increased from 0.2% to 4.1% at 14:05" not "The deployment caused the errors."
  • One focused query per question: Do not scatter-shot multiple queries when one precise query answers the question. Use parallel discovery calls, but be precise for execution.
  • Respect MCP server rules: The MCP server enforces rules about resource attribute filters, filter operators, and redundant queries. Follow them — especially preferring resource attributes in filters for faster queries.
  • No raw ClickHouse SQL: Always use the Query Builder tools. Never construct raw SQL.
  • Scope boundary: This skill queries data. If the user wants to wrap the query into a recurring alert, redirect to signoz-creating-alerts.
  • Emit apply_filter on the final message. When the user asks you to write, build, generate, or show a query, include an apply_filter action on your final assistant message with the exact full v5 query object you passed to a successful signoz_execute_builder_query call in this turn. The chip carries the entire query-range envelope (schemaVersion: "v1", start, end, requestType, compositeQuery), not just the inner compositeQuery, and you must copy it verbatim rather than reconstructing it. If you answered via simplified tools (signoz_search_logs, signoz_search_traces, signoz_aggregate_*, signoz_query_metrics), run one validating signoz_execute_builder_query with a small limit and copy that exact query object, or skip the chip. Use the appropriate signal field (metrics, logs, or traces). This signals to the SigNoz UI that the user wants to apply the query to an explorer page. Only emit apply_filter when the user's primary intent is to obtain a runnable query — not when the user is asking a one-shot data question that the analysis text already answers. For a Cost Meter query keep signal: metrics and ensure the copied query spec carries source: meter.

Examples

User: "Show me the error rate for the checkout service in the last hour"

Agent:

  1. Calls signoz_list_metrics(searchText: "calls", timeRange: "1h") and selects the exact returned request-count metric. In this example discovery returns signoz_calls_total with metricType: "sum", temporality: "cumulative", and isMonotonic: true.

  2. Calls signoz_get_field_keys(signal: "metrics", metricName: "signoz_calls_total") to discover both service and error labels, then signoz_get_field_values for each returned name / fieldContext with the same metric, confirming checkout-service and STATUS_CODE_ERROR. This example's returned names are service.name and status_code; use whatever names live discovery returns.

  3. Calls signoz_query_metrics with these complete arguments. The primary arguments define query A; formulaQueries explicitly defines query B with a different filter so the denominator includes every checkout request. Both filters use the label names returned in Step 2 verbatim:

    {
  "searchContext": "Show me the error rate for the checkout service in the last hour",
  "metricName": "signoz_calls_total",
  "metricType": "sum",
  "isMonotonic": true,
  "temporality": "cumulative",
  "timeAggregation": "increase",
  "spaceAggregation": "sum",
  "filter": "service.name = 'checkout-service' AND status_code = 'STATUS_CODE_ERROR'",
  "timeRange": "1h",
  "requestType": "scalar",
  "formula": "A / B * 100",
  "formulaQueries": [{
    "name": "B",
    "metricName": "signoz_calls_total",
    "metricType": "sum",
    "isMonotonic": true,
    "temporality": "cumulative",
    "timeAggregation": "increase",
    "spaceAggregation": "sum",
    "filter": "service.name = 'checkout-service'"
  }]
}

    Replace every concrete metric, metadata value, field, and field value above with the tenant's discovery results; never assume this example exists.

  4. Presents: "Error rate for checkout-service: 2.3% over the last hour (14:00– 15:00 UTC). 47 errors out of 2,041 total requests."

  5. Offers drill-down: "Want me to check which operations have the highest error rate?"

User: "Find timeout errors in logs"

Agent:

  1. Calls signoz_search_logs(searchText: "timeout", severity: "ERROR", timeRange: "1h").
  2. Presents: "Found 23 timeout errors in the last hour. Most are from payment-service (18) and gateway (5). Common pattern: 'context deadline exceeded' in gRPC calls to downstream-api."
  3. Offers: "Want me to check traces for these services to see where the timeouts occur?"

User: "What's the p99 latency for the cart service?"

Agent:

  1. Calls signoz_aggregate_traces(aggregation: "p99", aggregateOn: "duration_nano", service: "cart-service", requestType: "scalar", timeRange: "1h").
  2. Presents: "p99 latency for cart-service: 1.2s over the last hour."
  3. Offers: "Want me to break this down by operation or show the trend over time?"

User: "When did errors spike for the frontend?"

Agent:

  1. Calls signoz_aggregate_traces(aggregation: "count", error: "true", service: "frontend", requestType: "time_series", timeRange: "6h").
  2. Presents: "Error count for frontend over the last 6 hours. Spike at 11:30 UTC — error count jumped from ~5/min to ~45/min, returning to baseline by 12:15."
  3. Offers: "Want me to check what error types appeared during the spike?"

User: "How much log data is each service ingesting?"

Agent:

  1. Bytes by service → Cost Meter. signoz_list_metrics(searchText: "log", source: "meter") and selects the returned log-volume metric from its live name and unit.
  2. Calls signoz_execute_builder_query with the outer query wrapper, schemaVersion: "v1", integer Unix-ms range, requestType: "time_series", formatOptions, variables, and a builder spec using signal: "metrics", source: "meter", the discovered metric name and temporality, stepInterval: 3600, raw timeAggregation: "sum", spaceAggregation: "sum", and the service.name field returned by signoz_get_field_keys, copying its name, fieldDataType, fieldContext, and signal into groupBy.
  3. Excludes partial: true datapoints, sums complete hourly buckets per service, and presents per-service ingestion in the discovered unit. (If the meter lacks a requested attribute, fall back to a direct count and note that bytes remain meter-only.)