honeycombio.getQuerySpecification

Honeycomb 0.45.0, Jan 6 26

Honeycomb 0.45.0 published on Tuesday, Jan 6, 2026 by honeycombio

Schema (JSON)

honeycombio/terraform-provider-honeycombio

Honeycomb 0.45.0 published on Tuesday, Jan 6, 2026 by honeycombio

Schema (JSON)

honeycombio/terraform-provider-honeycombio

# Data Source:<span pulumi-lang-nodejs=" honeycombio.getQuerySpecification

" pulumi-lang-dotnet=" honeycombio.getQuerySpecification " pulumi-lang-go=" getQuerySpecification " pulumi-lang-python=" get_query_specification " pulumi-lang-yaml=" honeycombio.getQuerySpecification " pulumi-lang-java=" honeycombio.getQuerySpecification “> honeycombio.getQuerySpecification Generates a Query Specification in JSON format for use with resources that expect a JSON-formatted Query Specification like honeycombio.Query.

Using this data source to generate query specifications is optional. It is also valid to use literal JSON strings in your configuration or to use the file interpolation function to read a raw JSON query specification from a file.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as honeycombio from "@pulumi/honeycombio";

const example = honeycombio.getQuerySpecification({
    calculations: [{
        op: "AVG",
        column: "duration_ms",
    }],
    calculatedFields: [{
        name: "fast_enough",
        expression: "LTE($response.duration_ms, 200)",
    }],
    filters: [
        {
            column: "trace.parent_id",
            op: "does-not-exist",
        },
        {
            column: "app.tenant",
            op: "=",
            value: "ThatSpecialTenant",
        },
        {
            column: "fast_enough",
            op: "=",
            value: "false",
        },
    ],
    filterCombination: "AND",
    breakdowns: ["app.tenant"],
    timeRange: 28800,
    compareTimeOffset: 86400,
});
export const jsonQuery = example.then(example => example.json);

import pulumi
import pulumi_honeycombio as honeycombio

example = honeycombio.get_query_specification(calculations=[{
        "op": "AVG",
        "column": "duration_ms",
    }],
    calculated_fields=[{
        "name": "fast_enough",
        "expression": "LTE($response.duration_ms, 200)",
    }],
    filters=[
        {
            "column": "trace.parent_id",
            "op": "does-not-exist",
        },
        {
            "column": "app.tenant",
            "op": "=",
            "value": "ThatSpecialTenant",
        },
        {
            "column": "fast_enough",
            "op": "=",
            "value": "false",
        },
    ],
    filter_combination="AND",
    breakdowns=["app.tenant"],
    time_range=28800,
    compare_time_offset=86400)
pulumi.export("jsonQuery", example.json)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/honeycombio/honeycombio"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := honeycombio.GetQuerySpecification(ctx, &honeycombio.GetQuerySpecificationArgs{
			Calculations: []honeycombio.GetQuerySpecificationCalculation{
				{
					Op:     "AVG",
					Column: pulumi.StringRef("duration_ms"),
				},
			},
			CalculatedFields: []honeycombio.GetQuerySpecificationCalculatedField{
				{
					Name:       "fast_enough",
					Expression: "LTE($response.duration_ms, 200)",
				},
			},
			Filters: []honeycombio.GetQuerySpecificationFilter{
				{
					Column: "trace.parent_id",
					Op:     "does-not-exist",
				},
				{
					Column: "app.tenant",
					Op:     "=",
					Value:  pulumi.StringRef("ThatSpecialTenant"),
				},
				{
					Column: "fast_enough",
					Op:     "=",
					Value:  pulumi.StringRef("false"),
				},
			},
			FilterCombination: pulumi.StringRef("AND"),
			Breakdowns: []string{
				"app.tenant",
			},
			TimeRange:         pulumi.Float64Ref(28800),
			CompareTimeOffset: pulumi.Float64Ref(86400),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("jsonQuery", example.Json)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Honeycombio = Pulumi.Honeycombio;

return await Deployment.RunAsync(() => 
{
    var example = Honeycombio.GetQuerySpecification.Invoke(new()
    {
        Calculations = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationCalculationInputArgs
            {
                Op = "AVG",
                Column = "duration_ms",
            },
        },
        CalculatedFields = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationCalculatedFieldInputArgs
            {
                Name = "fast_enough",
                Expression = "LTE($response.duration_ms, 200)",
            },
        },
        Filters = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationFilterInputArgs
            {
                Column = "trace.parent_id",
                Op = "does-not-exist",
            },
            new Honeycombio.Inputs.GetQuerySpecificationFilterInputArgs
            {
                Column = "app.tenant",
                Op = "=",
                Value = "ThatSpecialTenant",
            },
            new Honeycombio.Inputs.GetQuerySpecificationFilterInputArgs
            {
                Column = "fast_enough",
                Op = "=",
                Value = "false",
            },
        },
        FilterCombination = "AND",
        Breakdowns = new[]
        {
            "app.tenant",
        },
        TimeRange = 28800,
        CompareTimeOffset = 86400,
    });

    return new Dictionary<string, object?>
    {
        ["jsonQuery"] = example.Apply(getQuerySpecificationResult => getQuerySpecificationResult.Json),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.honeycombio.HoneycombioFunctions;
import com.pulumi.honeycombio.inputs.GetQuerySpecificationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var example = HoneycombioFunctions.getQuerySpecification(GetQuerySpecificationArgs.builder()
            .calculations(GetQuerySpecificationCalculationArgs.builder()
                .op("AVG")
                .column("duration_ms")
                .build())
            .calculatedFields(GetQuerySpecificationCalculatedFieldArgs.builder()
                .name("fast_enough")
                .expression("LTE($response.duration_ms, 200)")
                .build())
            .filters(            
                GetQuerySpecificationFilterArgs.builder()
                    .column("trace.parent_id")
                    .op("does-not-exist")
                    .build(),
                GetQuerySpecificationFilterArgs.builder()
                    .column("app.tenant")
                    .op("=")
                    .value("ThatSpecialTenant")
                    .build(),
                GetQuerySpecificationFilterArgs.builder()
                    .column("fast_enough")
                    .op("=")
                    .value("false")
                    .build())
            .filterCombination("AND")
            .breakdowns("app.tenant")
            .timeRange(28800)
            .compareTimeOffset(86400)
            .build());

        ctx.export("jsonQuery", example.json());
    }
}

variables:
  example:
    fn::invoke:
      function: honeycombio:getQuerySpecification
      arguments:
        calculations:
          - op: AVG
            column: duration_ms
        calculatedFields:
          - name: fast_enough
            expression: LTE($response.duration_ms, 200)
        filters:
          - column: trace.parent_id
            op: does-not-exist
          - column: app.tenant
            op: =
            value: ThatSpecialTenant
          - column: fast_enough
            op: =
            value: false
        filterCombination: AND
        breakdowns:
          - app.tenant
        timeRange: 28800
        compareTimeOffset: 86400
outputs:
  jsonQuery: ${example.json}

Using getQuerySpecification

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getQuerySpecification(args: GetQuerySpecificationArgs, opts?: InvokeOptions): Promise<GetQuerySpecificationResult>
function getQuerySpecificationOutput(args: GetQuerySpecificationOutputArgs, opts?: InvokeOptions): Output<GetQuerySpecificationResult>

def get_query_specification(breakdowns: Optional[Sequence[str]] = None,
                            calculated_fields: Optional[Sequence[GetQuerySpecificationCalculatedField]] = None,
                            calculations: Optional[Sequence[GetQuerySpecificationCalculation]] = None,
                            compare_time_offset: Optional[float] = None,
                            end_time: Optional[float] = None,
                            filter_combination: Optional[str] = None,
                            filters: Optional[Sequence[GetQuerySpecificationFilter]] = None,
                            granularity: Optional[float] = None,
                            havings: Optional[Sequence[GetQuerySpecificationHaving]] = None,
                            limit: Optional[float] = None,
                            orders: Optional[Sequence[GetQuerySpecificationOrder]] = None,
                            start_time: Optional[float] = None,
                            time_range: Optional[float] = None,
                            opts: Optional[InvokeOptions] = None) -> GetQuerySpecificationResult
def get_query_specification_output(breakdowns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                            calculated_fields: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationCalculatedFieldArgs]]]] = None,
                            calculations: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationCalculationArgs]]]] = None,
                            compare_time_offset: Optional[pulumi.Input[float]] = None,
                            end_time: Optional[pulumi.Input[float]] = None,
                            filter_combination: Optional[pulumi.Input[str]] = None,
                            filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationFilterArgs]]]] = None,
                            granularity: Optional[pulumi.Input[float]] = None,
                            havings: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationHavingArgs]]]] = None,
                            limit: Optional[pulumi.Input[float]] = None,
                            orders: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationOrderArgs]]]] = None,
                            start_time: Optional[pulumi.Input[float]] = None,
                            time_range: Optional[pulumi.Input[float]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetQuerySpecificationResult]

func GetQuerySpecification(ctx *Context, args *GetQuerySpecificationArgs, opts ...InvokeOption) (*GetQuerySpecificationResult, error)
func GetQuerySpecificationOutput(ctx *Context, args *GetQuerySpecificationOutputArgs, opts ...InvokeOption) GetQuerySpecificationResultOutput

> Note: This function is named GetQuerySpecification in the Go SDK.

public static class GetQuerySpecification 
{
    public static Task<GetQuerySpecificationResult> InvokeAsync(GetQuerySpecificationArgs args, InvokeOptions? opts = null)
    public static Output<GetQuerySpecificationResult> Invoke(GetQuerySpecificationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetQuerySpecificationResult> getQuerySpecification(GetQuerySpecificationArgs args, InvokeOptions options)
public static Output<GetQuerySpecificationResult> getQuerySpecification(GetQuerySpecificationArgs args, InvokeOptions options)

fn::invoke:
  function: honeycombio:index/getQuerySpecification:getQuerySpecification
  arguments:
    # arguments dictionary

The following arguments are supported:

Breakdowns List<string>: A list of fields to group results by.
CalculatedFields List<GetQuerySpecificationCalculatedField>: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
Calculations List<GetQuerySpecificationCalculation>: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
CompareTimeOffset double: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
EndTime double: The absolute end time of the query's time range, in seconds since the Unix epoch.
FilterCombination string: How to combine multiple filters. Defaults to "AND".
Filters List<GetQuerySpecificationFilter>: Zero or more configuration blocks describing the filters to apply to the query results.
Granularity double: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
Havings List<GetQuerySpecificationHaving>: Zero or more configuration blocks used to restrict returned groups in the query result.
Limit double: The maximum number of results to return. Defaults to 1000.
Orders List<GetQuerySpecificationOrder>: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
StartTime double: The absolute start time of the query's time range, in seconds since the Unix epoch.
TimeRange double: The time range of the query, in seconds. Defaults to 7200.

Breakdowns []string: A list of fields to group results by.
CalculatedFields []GetQuerySpecificationCalculatedField: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
Calculations []GetQuerySpecificationCalculation: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
CompareTimeOffset float64: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
EndTime float64: The absolute end time of the query's time range, in seconds since the Unix epoch.
FilterCombination string: How to combine multiple filters. Defaults to "AND".
Filters []GetQuerySpecificationFilter: Zero or more configuration blocks describing the filters to apply to the query results.
Granularity float64: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
Havings []GetQuerySpecificationHaving: Zero or more configuration blocks used to restrict returned groups in the query result.
Limit float64: The maximum number of results to return. Defaults to 1000.
Orders []GetQuerySpecificationOrder: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
StartTime float64: The absolute start time of the query's time range, in seconds since the Unix epoch.
TimeRange float64: The time range of the query, in seconds. Defaults to 7200.

breakdowns List<String>: A list of fields to group results by.
calculatedFields List<GetQuerySpecificationCalculatedField>: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations List<GetQuerySpecificationCalculation>: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compareTimeOffset Double: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
endTime Double: The absolute end time of the query's time range, in seconds since the Unix epoch.
filterCombination String: How to combine multiple filters. Defaults to "AND".
filters List<GetQuerySpecificationFilter>: Zero or more configuration blocks describing the filters to apply to the query results.
granularity Double: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings List<GetQuerySpecificationHaving>: Zero or more configuration blocks used to restrict returned groups in the query result.
limit Double: The maximum number of results to return. Defaults to 1000.
orders List<GetQuerySpecificationOrder>: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
startTime Double: The absolute start time of the query's time range, in seconds since the Unix epoch.
timeRange Double: The time range of the query, in seconds. Defaults to 7200.

breakdowns string[]: A list of fields to group results by.
calculatedFields GetQuerySpecificationCalculatedField[]: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations GetQuerySpecificationCalculation[]: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compareTimeOffset number: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
endTime number: The absolute end time of the query's time range, in seconds since the Unix epoch.
filterCombination string: How to combine multiple filters. Defaults to "AND".
filters GetQuerySpecificationFilter[]: Zero or more configuration blocks describing the filters to apply to the query results.
granularity number: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings GetQuerySpecificationHaving[]: Zero or more configuration blocks used to restrict returned groups in the query result.
limit number: The maximum number of results to return. Defaults to 1000.
orders GetQuerySpecificationOrder[]: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
startTime number: The absolute start time of the query's time range, in seconds since the Unix epoch.
timeRange number: The time range of the query, in seconds. Defaults to 7200.

breakdowns Sequence[str]: A list of fields to group results by.
calculated_fields Sequence[GetQuerySpecificationCalculatedField]: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations Sequence[GetQuerySpecificationCalculation]: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compare_time_offset float: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
end_time float: The absolute end time of the query's time range, in seconds since the Unix epoch.
filter_combination str: How to combine multiple filters. Defaults to "AND".
filters Sequence[GetQuerySpecificationFilter]: Zero or more configuration blocks describing the filters to apply to the query results.
granularity float: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings Sequence[GetQuerySpecificationHaving]: Zero or more configuration blocks used to restrict returned groups in the query result.
limit float: The maximum number of results to return. Defaults to 1000.
orders Sequence[GetQuerySpecificationOrder]: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
start_time float: The absolute start time of the query's time range, in seconds since the Unix epoch.
time_range float: The time range of the query, in seconds. Defaults to 7200.

breakdowns List<String>: A list of fields to group results by.
calculatedFields List<Property Map>: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations List<Property Map>: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compareTimeOffset Number: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
endTime Number: The absolute end time of the query's time range, in seconds since the Unix epoch.
filterCombination String: How to combine multiple filters. Defaults to "AND".
filters List<Property Map>: Zero or more configuration blocks describing the filters to apply to the query results.
granularity Number: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings List<Property Map>: Zero or more configuration blocks used to restrict returned groups in the query result.
limit Number: The maximum number of results to return. Defaults to 1000.
orders List<Property Map>: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
startTime Number: The absolute start time of the query's time range, in seconds since the Unix epoch.
timeRange Number: The time range of the query, in seconds. Defaults to 7200.

getQuerySpecification Result

The following output properties are available:

Id string: The ID of the query specification.
Deprecated: Deprecated
Json string: JSON representation of the query according to the Query Specification, can be used as input for other resources.
Breakdowns List<string>: A list of fields to group results by.
CalculatedFields List<GetQuerySpecificationCalculatedField>: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
Calculations List<GetQuerySpecificationCalculation>: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
CompareTimeOffset double: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
EndTime double: The absolute end time of the query's time range, in seconds since the Unix epoch.
FilterCombination string: How to combine multiple filters. Defaults to "AND".
Filters List<GetQuerySpecificationFilter>: Zero or more configuration blocks describing the filters to apply to the query results.
Granularity double: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
Havings List<GetQuerySpecificationHaving>: Zero or more configuration blocks used to restrict returned groups in the query result.
Limit double: The maximum number of results to return. Defaults to 1000.
Orders List<GetQuerySpecificationOrder>: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
StartTime double: The absolute start time of the query's time range, in seconds since the Unix epoch.
TimeRange double: The time range of the query, in seconds. Defaults to 7200.

Id string: The ID of the query specification.
Deprecated: Deprecated
Json string: JSON representation of the query according to the Query Specification, can be used as input for other resources.
Breakdowns []string: A list of fields to group results by.
CalculatedFields []GetQuerySpecificationCalculatedField: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
Calculations []GetQuerySpecificationCalculation: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
CompareTimeOffset float64: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
EndTime float64: The absolute end time of the query's time range, in seconds since the Unix epoch.
FilterCombination string: How to combine multiple filters. Defaults to "AND".
Filters []GetQuerySpecificationFilter: Zero or more configuration blocks describing the filters to apply to the query results.
Granularity float64: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
Havings []GetQuerySpecificationHaving: Zero or more configuration blocks used to restrict returned groups in the query result.
Limit float64: The maximum number of results to return. Defaults to 1000.
Orders []GetQuerySpecificationOrder: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
StartTime float64: The absolute start time of the query's time range, in seconds since the Unix epoch.
TimeRange float64: The time range of the query, in seconds. Defaults to 7200.

id String: The ID of the query specification.
Deprecated: Deprecated
json String: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns List<String>: A list of fields to group results by.
calculatedFields List<GetQuerySpecificationCalculatedField>: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations List<GetQuerySpecificationCalculation>: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compareTimeOffset Double: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
endTime Double: The absolute end time of the query's time range, in seconds since the Unix epoch.
filterCombination String: How to combine multiple filters. Defaults to "AND".
filters List<GetQuerySpecificationFilter>: Zero or more configuration blocks describing the filters to apply to the query results.
granularity Double: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings List<GetQuerySpecificationHaving>: Zero or more configuration blocks used to restrict returned groups in the query result.
limit Double: The maximum number of results to return. Defaults to 1000.
orders List<GetQuerySpecificationOrder>: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
startTime Double: The absolute start time of the query's time range, in seconds since the Unix epoch.
timeRange Double: The time range of the query, in seconds. Defaults to 7200.

id string: The ID of the query specification.
Deprecated: Deprecated
json string: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns string[]: A list of fields to group results by.
calculatedFields GetQuerySpecificationCalculatedField[]: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations GetQuerySpecificationCalculation[]: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compareTimeOffset number: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
endTime number: The absolute end time of the query's time range, in seconds since the Unix epoch.
filterCombination string: How to combine multiple filters. Defaults to "AND".
filters GetQuerySpecificationFilter[]: Zero or more configuration blocks describing the filters to apply to the query results.
granularity number: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings GetQuerySpecificationHaving[]: Zero or more configuration blocks used to restrict returned groups in the query result.
limit number: The maximum number of results to return. Defaults to 1000.
orders GetQuerySpecificationOrder[]: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
startTime number: The absolute start time of the query's time range, in seconds since the Unix epoch.
timeRange number: The time range of the query, in seconds. Defaults to 7200.

id str: The ID of the query specification.
Deprecated: Deprecated
json str: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns Sequence[str]: A list of fields to group results by.
calculated_fields Sequence[GetQuerySpecificationCalculatedField]: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations Sequence[GetQuerySpecificationCalculation]: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compare_time_offset float: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
end_time float: The absolute end time of the query's time range, in seconds since the Unix epoch.
filter_combination str: How to combine multiple filters. Defaults to "AND".
filters Sequence[GetQuerySpecificationFilter]: Zero or more configuration blocks describing the filters to apply to the query results.
granularity float: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings Sequence[GetQuerySpecificationHaving]: Zero or more configuration blocks used to restrict returned groups in the query result.
limit float: The maximum number of results to return. Defaults to 1000.
orders Sequence[GetQuerySpecificationOrder]: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
start_time float: The absolute start time of the query's time range, in seconds since the Unix epoch.
time_range float: The time range of the query, in seconds. Defaults to 7200.

id String: The ID of the query specification.
Deprecated: Deprecated
json String: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns List<String>: A list of fields to group results by.
calculatedFields List<Property Map>: Zero or more configuration blocks describing the Calculated Fields to create for use in this query.
calculations List<Property Map>: Zero or more configuration blocks describing the calculations to return as a time series and summary table. If no calculations are provided, "COUNT" is assumed.
compareTimeOffset Number: The time offset for comparison queries, in seconds. Used to compare current time range data with data from a previous time period.
endTime Number: The absolute end time of the query's time range, in seconds since the Unix epoch.
filterCombination String: How to combine multiple filters. Defaults to "AND".
filters List<Property Map>: Zero or more configuration blocks describing the filters to apply to the query results.
granularity Number: The time resolution of the query's graph, in seconds. Valid values must be in between the query's time range at maximum, and /1000 at minimum.
havings List<Property Map>: Zero or more configuration blocks used to restrict returned groups in the query result.
limit Number: The maximum number of results to return. Defaults to 1000.
orders List<Property Map>: Zero or more configuration blocks describing how to order the query results. Each term must appear as a "calculation" or in "breakdowns".
startTime Number: The absolute start time of the query's time range, in seconds since the Unix epoch.
timeRange Number: The time range of the query, in seconds. Defaults to 7200.

Supporting Types

GetQuerySpecificationCalculatedField

Expression string: The formula to use for the Calculated Field. See the Calculated Field Formula Reference for syntax and functions.
Name string: The name of the Calculated Field.

Expression string: The formula to use for the Calculated Field. See the Calculated Field Formula Reference for syntax and functions.
Name string: The name of the Calculated Field.

expression String: The formula to use for the Calculated Field. See the Calculated Field Formula Reference for syntax and functions.
name String: The name of the Calculated Field.

expression string: The formula to use for the Calculated Field. See the Calculated Field Formula Reference for syntax and functions.
name string: The name of the Calculated Field.

expression str: The formula to use for the Calculated Field. See the Calculated Field Formula Reference for syntax and functions.
name str: The name of the Calculated Field.

expression String: The formula to use for the Calculated Field. See the Calculated Field Formula Reference for syntax and functions.
name String: The name of the Calculated Field.

GetQuerySpecificationCalculation

Op string: The operator to apply. See the supported list at Calculation Operators.
Column string: The column to apply the operator on. Not allowed with "COUNT" or "CONCURRENCY", required for all other operators.

Op string: The operator to apply. See the supported list at Calculation Operators.
Column string: The column to apply the operator on. Not allowed with "COUNT" or "CONCURRENCY", required for all other operators.

op String: The operator to apply. See the supported list at Calculation Operators.
column String: The column to apply the operator on. Not allowed with "COUNT" or "CONCURRENCY", required for all other operators.

op string: The operator to apply. See the supported list at Calculation Operators.
column string: The column to apply the operator on. Not allowed with "COUNT" or "CONCURRENCY", required for all other operators.

op str: The operator to apply. See the supported list at Calculation Operators.
column str: The column to apply the operator on. Not allowed with "COUNT" or "CONCURRENCY", required for all other operators.

op String: The operator to apply. See the supported list at Calculation Operators.
column String: The column to apply the operator on. Not allowed with "COUNT" or "CONCURRENCY", required for all other operators.

GetQuerySpecificationFilter

Column string: The column to filter on.
Op string: The operator to apply. See the supported list at Filter Operators. Not all operators require a value.
Value string: The value used for the filter. Not needed if op is "exists" or "not-exists".

Column string: The column to filter on.
Op string: The operator to apply. See the supported list at Filter Operators. Not all operators require a value.
Value string: The value used for the filter. Not needed if op is "exists" or "not-exists".

column String: The column to filter on.
op String: The operator to apply. See the supported list at Filter Operators. Not all operators require a value.
value String: The value used for the filter. Not needed if op is "exists" or "not-exists".

column string: The column to filter on.
op string: The operator to apply. See the supported list at Filter Operators. Not all operators require a value.
value string: The value used for the filter. Not needed if op is "exists" or "not-exists".

column str: The column to filter on.
op str: The operator to apply. See the supported list at Filter Operators. Not all operators require a value.
value str: The value used for the filter. Not needed if op is "exists" or "not-exists".

column String: The column to filter on.
op String: The operator to apply. See the supported list at Filter Operators. Not all operators require a value.
value String: The value used for the filter. Not needed if op is "exists" or "not-exists".

GetQuerySpecificationHaving

CalculateOp string: The calculation operator to apply. Supports all Calculation Operators except HEATMAP.
Op string: The operator to apply.
Value double: The value used for the filter.
Column string: The column to filter on. Not allowed with "COUNT".

CalculateOp string: The calculation operator to apply. Supports all Calculation Operators except HEATMAP.
Op string: The operator to apply.
Value float64: The value used for the filter.
Column string: The column to filter on. Not allowed with "COUNT".

calculateOp String: The calculation operator to apply. Supports all Calculation Operators except HEATMAP.
op String: The operator to apply.
value Double: The value used for the filter.
column String: The column to filter on. Not allowed with "COUNT".

calculateOp string: The calculation operator to apply. Supports all Calculation Operators except HEATMAP.
op string: The operator to apply.
value number: The value used for the filter.
column string: The column to filter on. Not allowed with "COUNT".

calculate_op str: The calculation operator to apply. Supports all Calculation Operators except HEATMAP.
op str: The operator to apply.
value float: The value used for the filter.
column str: The column to filter on. Not allowed with "COUNT".

calculateOp String: The calculation operator to apply. Supports all Calculation Operators except HEATMAP.
op String: The operator to apply.
value Number: The value used for the filter.
column String: The column to filter on. Not allowed with "COUNT".

GetQuerySpecificationOrder

Column string: Either a column present in "breakdown" or a column that "op" applies to.
Op string: The calculation operator to apply. See the supported list at Calculation Operators.
Order string: The sort order to apply.

Column string: Either a column present in "breakdown" or a column that "op" applies to.
Op string: The calculation operator to apply. See the supported list at Calculation Operators.
Order string: The sort order to apply.

column String: Either a column present in "breakdown" or a column that "op" applies to.
op String: The calculation operator to apply. See the supported list at Calculation Operators.
order String: The sort order to apply.

column string: Either a column present in "breakdown" or a column that "op" applies to.
op string: The calculation operator to apply. See the supported list at Calculation Operators.
order string: The sort order to apply.

column str: Either a column present in "breakdown" or a column that "op" applies to.
op str: The calculation operator to apply. See the supported list at Calculation Operators.
order str: The sort order to apply.

column String: Either a column present in "breakdown" or a column that "op" applies to.
op String: The calculation operator to apply. See the supported list at Calculation Operators.
order String: The sort order to apply.