Skip to main content
Beta Build multi-step, math-driven queries directly in Honeycomb—no calculated fields required.
This feature is in beta, and we would love your feedback!To opt in, join our Pollinators Community Slack and ping us in the #discuss-metrics channel. Pro and Enterprise users can also contact Honeycomb Support or email support@honeycomb.io.

​
Introduction

Query Math adds support for multi-step queries in Honeycomb. You can now define multiple query steps, perform math between them, and visualize the final result—all inline in the Query Builder. This feature helps you express richer queries without creating temporary calculated fields. Instead of building complex calculated field expressions, you can break down your analysis into logical steps and combine them using simple mathematical formulas. Use Query Math to:
  • Calculate ratios and percentages directly in your query
  • Combine multiple aggregates (for example, error counts and request totals)
  • Perform time-series math with functions like RATE() and INCREASE()
  • Simplify complex calculated fields into inline formulas
  • Compare conditional aggregations side by side

​
How It Works

Query Math lets you create multiple query steps, such as Step A and Step B—each with its own SELECT, WHERE, and GROUP BY clauses. You can then define a formula that references these steps using variables like $A, $B, and so on. When you run the query, Honeycomb:
  1. Executes each step independently.
  2. Evaluates your formula using the results from each step.
  3. Visualizes the final result.
Only the final formula result appears in your visualization.
To see individual step results, remove the formula from your query.

​
Using Query Math

To build a query with Query Math:
  1. Select Query () from the navigation menu.
  2. Select the Metrics dataset.
  3. Define your first step (Step A):
    1. Select fields in the SELECT clause.
    2. Add filters in the WHERE clause.
    3. Optionally, add groupings in the GROUP BY clause.
  4. Select Add Query to create additional steps (for example, Step B).
  5. Select Add Formula to define the mathematical relationship between your query steps.
  6. In the formula editor, reference your steps using $A, $B, and so on, and combine them using mathematical operators.
  7. Select Run Query to see the result.
All query steps must use the same GROUP BY dimensions. For example, if Step A groups by k8s.pod.name, then Step B must also group by k8s.pod.name.
Screenshot of Query Builder, showing two query steps (A) and (B), and a query math formula (C)

​
Supported Operators

Query Math supports standard mathematical operators in intuitive infix notation:
OperatorDescriptionExample
+Addition$A + $B
-Subtraction$A - $B
*Multiplication$A * $B
/Division$A / $B
()Parentheses for grouping($A + $B) / $C
You can combine these operators to create complex formulas: 
(($A / $B) * 100)
Include spaces around arithmetic operators to ensure that the formula parses correctly.
This is more intuitive than nested function notation (MULTIPLY(DIVIDE($A, $B), 100)) and easier to read at a glance.

​
Examples

These examples demonstrate common use cases for Query Math. Each shows how to structure your query stages and combine them with formulas.

​
Error Rate

Compute the percentage of all requests that resulted in 500 errors. Step A:
  • SELECT COUNT
  • WHERE status = 500
Step B:
  • SELECT COUNT
Formula C: 
($A / $B) * 100

​
Success Rate

Calculate the percentage of successful requests (non-error status codes). Step A:
  • SELECT COUNT
  • WHERE status < 400
Step B:
  • SELECT COUNT
Formula C: 
($A / $B) * 100

​
Memory Utilization Percentage

Calculate the percentage of available memory that is currently in use, which makes it easier to identify which pods are approaching capacity. Step A:
  • SELECT MAX(k8s.pod.memory.usage)
Step B:
  • SELECT MAX(k8s.pod.memory.available)
Formula C: 
($A / ($A / $B)) * 100

​
Request Rate Difference

Compare the request rate between two services, which can help you identify load imbalances. Step A:
  • SELECT AVG(request_rate) (create query-scoped calculated field request_rate with definition RATE($http.server.requests))
  • WHERE service.name = "api"
Step B:
  • SELECT AVG(request_rate)
  • WHERE service.name = "frontend"
Query-scoped calculated fields defined in any step are automatically available in all other steps within the same query.
Formula C: 
$A - $B

​
CPU Usage Patterns

Combine different temporal aggregation functions to analyze metric behavior. This query compares the current CPU utilization snapshot against the rate of change, helping you understand CPU usage patterns. Step A:
  • SELECT AVG(last_cpu) (create query-scoped calculated field last_cpu with definition LAST($k8s.pod.cpu.utilization))
Step B:
  • SELECT AVG(rate_cpu) (create query-scoped calculated field rate_cpu with definition RATE($k8s.pod.cpu.time))
Formula C: 
$A / $B

​
Working with Groupings

When using GROUP BY in Query Math, all query steps must group by the same dimensions. This ensures that Honeycomb can align the results correctly when evaluating the formula. For example, if you want to calculate error rates per route: Step A:
  • SELECT COUNT
  • WHERE status >= 400
  • GROUP BY http.route
Step B:
  • SELECT COUNT
  • GROUP BY http.route
Formula C: 
($A / $B) * 100
Honeycomb evaluates the formula for each unique value of http.route, producing a separate result for each route.
If your query steps have different GROUP BY clauses, the query will fail. Ensure all steps use the same grouping dimensions before adding a formula.

​
Combining with Temporal Aggregation

Query Math works seamlessly with temporal aggregation functions. You can use RATE(), INCREASE(), SUMMARIZE(), and LAST() in your query steps, then perform math across the results. For example, to calculate your error rate as a percentage of total throughput: Step A:
  • SELECT SUM(error_rate) (create query-scoped calculated field error_rate with definition RATE($http.server.errors) )
Step B:
  • SELECT SUM(request_rate) (create query-scoped calculated field request_rate with definition RATE($http.server.requests))
Formula C: 
($A / $B) * 100
This query shows what percentage of your requests per second are errors, using temporal aggregation to normalize both metrics to per-second rates before calculating the ratio.

​
Visualizing Results

When you add a formula to your query, only the formula result appears in the visualization. This keeps your charts focused on the final calculated value. If you want to see the individual step results alongside the formula:
  1. Remove the formula temporarily.
  2. Run the query to see each step’s results independently.
  3. Add the formula back when ready.
This workflow is useful for debugging or validating intermediate results before combining them.

​
Tips for Building Queries

Use these strategies to build effective Query Math queries:
  • Start simple: Build and test each query step individually before adding a formula.
  • Use descriptive calculated field names: Names like error_rate or memory_util make steps easier to understand.
  • Validate groupings: Ensure all steps use identical GROUP BY clauses to avoid query errors.
  • Test incrementally: Add one formula operation at a time to isolate any issues.
  • Use parentheses: Explicitly group operations to control evaluation order, especially in complex formulas.

​
Limitations

Keep the following constraints in mind when working with Query Math:
  • Query Math is available only for Metrics datasets. Support for Events datasets is coming in Q1 2026.
  • All query steps must use the same GROUP BY dimensions. Re-aggregations across different groupings are not supported.
  • When a formula is present, only the formula result is visualized. Remove the formula to see individual step results.
  • Query Math is available only in the Query Builder UI. API and Trigger support is coming in Q1 2026.
  • You cannot use the result of one step as input to another step.

​
What’s Next

Query Math is actively evolving based on user feedback. Upcoming improvements include:
  • Support for Events datasets (Q1 2026)
  • API integration for programmatic queries (Q1 2026)
  • Trigger support for alerting on formula results (Q1 2026)
  • Enhanced visualization options for viewing individual query steps alongside formulas

​
Feedback Welcome

Query Math is in active beta, and your feedback shapes its development. We’d love to hear about:
  • Use cases where Query Math simplifies your workflow
  • Limitations that block your analysis
  • Formula patterns you find yourself using repeatedly
  • Visualization improvements that would help your team
Share your feedback in the Pollinators Community Slack in the #discuss-metrics channel, or reach out to Honeycomb Support.