Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Chronosphere
  4. API Docs
  5. SLO
Viewing docs for Chronosphere v0.9.16
published on Friday, Jun 5, 2026 by Chronosphere
Schema (JSON)
chronosphereio/pulumi-chronosphere

chronosphere.SLO

Viewing docs for Chronosphere v0.9.16
published on Friday, Jun 5, 2026 by Chronosphere
Schema (JSON)
chronosphereio/pulumi-chronosphere

    A service-level objective that tracks the ratio of good to total events produced by an SLI over a configured time window, with optional multi-window burn-rate alerting.

    Example Usage

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

return await Deployment.RunAsync(() => 
{
    var payments = new Pulumi.Team("payments", new()
    {
        Name = "Payments",
    });

    var blackhole = new Pulumi.BlackholeAlertNotifier("blackhole", new()
    {
        Name = "Blackhole",
    });

    var np = new Pulumi.NotificationPolicy("np", new()
    {
        Name = "SLO policy",
        TeamId = payments.Id,
        Routes = new[]
        {
            new Pulumi.Inputs.NotificationPolicyRouteArgs
            {
                Severity = "warn",
                Notifiers = new[]
                {
                    blackhole.Id,
                },
            },
        },
    });

    var collection = new Pulumi.Collection("collection", new()
    {
        Name = "Payments",
        TeamId = payments.Id,
    });

    var requestSuccess = new Pulumi.SLO("requestSuccess", new()
    {
        Name = "payments request success",
        CollectionId = collection.Id,
        NotificationPolicyId = np.Id,
        Definition = new Pulumi.Inputs.SLODefinitionArgs
        {
            Objective = 99.95,
            TimeWindow = new Pulumi.Inputs.SLODefinitionTimeWindowArgs
            {
                Duration = "28d",
            },
            EnableBurnRateAlerting = true,
        },
        Sli = new Pulumi.Inputs.SLOSliArgs
        {
            CustomIndicator = new Pulumi.Inputs.SLOSliCustomIndicatorArgs
            {
                BadQueryTemplate = "sum(rate(http_request_duration_seconds_count{error=\"true\"}[{{ .Window }}]))",
                TotalQueryTemplate = "sum(rate(http_request_duration_seconds_count[{{ .Window }}]))",
            },
        },
    });

});

    package main

import (
	"github.com/chronosphereio/pulumi-chronosphere/sdk/go/chronosphere"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		payments, err := chronosphere.NewTeam(ctx, "payments", &chronosphere.TeamArgs{
			Name: pulumi.String("Payments"),
		})
		if err != nil {
			return err
		}
		blackhole, err := chronosphere.NewBlackholeAlertNotifier(ctx, "blackhole", &chronosphere.BlackholeAlertNotifierArgs{
			Name: pulumi.String("Blackhole"),
		})
		if err != nil {
			return err
		}
		np, err := chronosphere.NewNotificationPolicy(ctx, "np", &chronosphere.NotificationPolicyArgs{
			Name:   pulumi.String("SLO policy"),
			TeamId: payments.ID(),
			Routes: chronosphere.NotificationPolicyRouteArray{
				&chronosphere.NotificationPolicyRouteArgs{
					Severity: pulumi.String("warn"),
					Notifiers: pulumi.StringArray{
						blackhole.ID(),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		collection, err := chronosphere.NewCollection(ctx, "collection", &chronosphere.CollectionArgs{
			Name:   pulumi.String("Payments"),
			TeamId: payments.ID(),
		})
		if err != nil {
			return err
		}
		_, err = chronosphere.NewSLO(ctx, "requestSuccess", &chronosphere.SLOArgs{
			Name:                 pulumi.String("payments request success"),
			CollectionId:         collection.ID(),
			NotificationPolicyId: np.ID(),
			Definition: &chronosphere.SLODefinitionArgs{
				Objective: pulumi.Float64(99.95),
				TimeWindow: &chronosphere.SLODefinitionTimeWindowArgs{
					Duration: pulumi.String("28d"),
				},
				EnableBurnRateAlerting: pulumi.Bool(true),
			},
			Sli: &chronosphere.SLOSliArgs{
				CustomIndicator: &chronosphere.SLOSliCustomIndicatorArgs{
					BadQueryTemplate:   pulumi.String("sum(rate(http_request_duration_seconds_count{error=\"true\"}[{{ .Window }}]))"),
					TotalQueryTemplate: pulumi.String("sum(rate(http_request_duration_seconds_count[{{ .Window }}]))"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    Example coming soon!

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.chronosphere.Team;
import com.pulumi.chronosphere.TeamArgs;
import com.pulumi.chronosphere.BlackholeAlertNotifier;
import com.pulumi.chronosphere.BlackholeAlertNotifierArgs;
import com.pulumi.chronosphere.NotificationPolicy;
import com.pulumi.chronosphere.NotificationPolicyArgs;
import com.pulumi.chronosphere.inputs.NotificationPolicyRouteArgs;
import com.pulumi.chronosphere.Collection;
import com.pulumi.chronosphere.CollectionArgs;
import com.pulumi.chronosphere.SLO;
import com.pulumi.chronosphere.SLOArgs;
import com.pulumi.chronosphere.inputs.SLODefinitionArgs;
import com.pulumi.chronosphere.inputs.SLODefinitionTimeWindowArgs;
import com.pulumi.chronosphere.inputs.SLOSliArgs;
import com.pulumi.chronosphere.inputs.SLOSliCustomIndicatorArgs;
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) {
        var payments = new Team("payments", TeamArgs.builder()        
            .name("Payments")
            .build());

        var blackhole = new BlackholeAlertNotifier("blackhole", BlackholeAlertNotifierArgs.builder()        
            .name("Blackhole")
            .build());

        var np = new NotificationPolicy("np", NotificationPolicyArgs.builder()        
            .name("SLO policy")
            .teamId(payments.id())
            .routes(NotificationPolicyRouteArgs.builder()
                .severity("warn")
                .notifiers(blackhole.id())
                .build())
            .build());

        var collection = new Collection("collection", CollectionArgs.builder()        
            .name("Payments")
            .teamId(payments.id())
            .build());

        var requestSuccess = new SLO("requestSuccess", SLOArgs.builder()        
            .name("payments request success")
            .collectionId(collection.id())
            .notificationPolicyId(np.id())
            .definition(SLODefinitionArgs.builder()
                .objective(99.95)
                .timeWindow(SLODefinitionTimeWindowArgs.builder()
                    .duration("28d")
                    .build())
                .enableBurnRateAlerting(true)
                .build())
            .sli(SLOSliArgs.builder()
                .customIndicator(SLOSliCustomIndicatorArgs.builder()
                    .badQueryTemplate("sum(rate(http_request_duration_seconds_count{error=\"true\"}[{{ .Window }}]))")
                    .totalQueryTemplate("sum(rate(http_request_duration_seconds_count[{{ .Window }}]))")
                    .build())
                .build())
            .build());

    }
}

    import * as pulumi from "@pulumi/pulumi";
import * as chronosphere from "@pulumi-chronosphere/pulumi-chronosphere";

const payments = new chronosphere.Team("payments", {name: "Payments"});
const blackhole = new chronosphere.BlackholeAlertNotifier("blackhole", {name: "Blackhole"});
const np = new chronosphere.NotificationPolicy("np", {
    name: "SLO policy",
    teamId: payments.id,
    routes: [{
        severity: "warn",
        notifiers: [blackhole.id],
    }],
});
const collection = new chronosphere.Collection("collection", {
    name: "Payments",
    teamId: payments.id,
});
const requestSuccess = new chronosphere.SLO("requestSuccess", {
    name: "payments request success",
    collectionId: collection.id,
    notificationPolicyId: np.id,
    definition: {
        objective: 99.95,
        timeWindow: {
            duration: "28d",
        },
        enableBurnRateAlerting: true,
    },
    sli: {
        customIndicator: {
            badQueryTemplate: "sum(rate(http_request_duration_seconds_count{error=\"true\"}[{{ .Window }}]))",
            totalQueryTemplate: "sum(rate(http_request_duration_seconds_count[{{ .Window }}]))",
        },
    },
});

    import pulumi
import pulumi_chronosphere as chronosphere

payments = chronosphere.Team("payments", name="Payments")
blackhole = chronosphere.BlackholeAlertNotifier("blackhole", name="Blackhole")
np = chronosphere.NotificationPolicy("np",
    name="SLO policy",
    team_id=payments.id,
    routes=[chronosphere.NotificationPolicyRouteArgs(
        severity="warn",
        notifiers=[blackhole.id],
    )])
collection = chronosphere.Collection("collection",
    name="Payments",
    team_id=payments.id)
request_success = chronosphere.SLO("requestSuccess",
    name="payments request success",
    collection_id=collection.id,
    notification_policy_id=np.id,
    definition=chronosphere.SLODefinitionArgs(
        objective=99.95,
        time_window=chronosphere.SLODefinitionTimeWindowArgs(
            duration="28d",
        ),
        enable_burn_rate_alerting=True,
    ),
    sli=chronosphere.SLOSliArgs(
        custom_indicator=chronosphere.SLOSliCustomIndicatorArgs(
            bad_query_template="sum(rate(http_request_duration_seconds_count{error=\"true\"}[{{ .Window }}]))",
            total_query_template="sum(rate(http_request_duration_seconds_count[{{ .Window }}]))",
        ),
    ))

    resources:
  payments:
    type: chronosphere:Team
    properties:
      name: Payments
  blackhole:
    type: chronosphere:BlackholeAlertNotifier
    properties:
      name: Blackhole
  np:
    type: chronosphere:NotificationPolicy
    properties:
      name: SLO policy
      teamId: ${payments.id}
      routes:
        - severity: warn
          notifiers:
            - ${blackhole.id}
  collection:
    type: chronosphere:Collection
    properties:
      name: Payments
      teamId: ${payments.id}
  requestSuccess:
    type: chronosphere:SLO
    properties:
      name: payments request success
      collectionId: ${collection.id}
      notificationPolicyId: ${np.id}
      definition:
        objective: 99.95
        timeWindow:
          duration: 28d
        enableBurnRateAlerting: true
      sli:
        customIndicator:
          badQueryTemplate: sum(rate(http_request_duration_seconds_count{error="true"}[{{ .Window }}]))
          totalQueryTemplate: sum(rate(http_request_duration_seconds_count[{{ .Window }}]))

    Create SLO Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new SLO(name: string, args: SLOArgs, opts?: CustomResourceOptions);
    @overload
def SLO(resource_name: str,
        args: SLOArgs,
        opts: Optional[ResourceOptions] = None)

@overload
def SLO(resource_name: str,
        opts: Optional[ResourceOptions] = None,
        collection_id: Optional[str] = None,
        definition: Optional[SLODefinitionArgs] = None,
        name: Optional[str] = None,
        sli: Optional[SLOSliArgs] = None,
        annotations: Optional[Mapping[str, str]] = None,
        description: Optional[str] = None,
        labels: Optional[Mapping[str, str]] = None,
        notification_policy_id: Optional[str] = None,
        signal_grouping: Optional[SLOSignalGroupingArgs] = None,
        slug: Optional[str] = None)
    func NewSLO(ctx *Context, name string, args SLOArgs, opts ...ResourceOption) (*SLO, error)
    public SLO(string name, SLOArgs args, CustomResourceOptions? opts = null)
    public SLO(String name, SLOArgs args)
public SLO(String name, SLOArgs args, CustomResourceOptions options)

    type: chronosphere:SLO
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "chronosphere_slo" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args SLOArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args SLOArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args SLOArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args SLOArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args SLOArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var sloResource = new Pulumi.SLO("sloResource", new()
{
    CollectionId = "string",
    Definition = new Pulumi.Inputs.SLODefinitionArgs
    {
        Objective = 0,
        BurnRateAlertingConfigs = new[]
        {
            new Pulumi.Inputs.SLODefinitionBurnRateAlertingConfigArgs
            {
                Budget = 0,
                Severity = "string",
                Window = "string",
                Labels = 
                {
                    { "string", "string" },
                },
            },
        },
        EnableBurnRateAlerting = false,
        TimeWindow = new Pulumi.Inputs.SLODefinitionTimeWindowArgs
        {
            Duration = "string",
        },
    },
    Name = "string",
    Sli = new Pulumi.Inputs.SLOSliArgs
    {
        AdditionalPromqlFilters = new[]
        {
            new Pulumi.Inputs.SLOSliAdditionalPromqlFilterArgs
            {
                Name = "string",
                Type = "string",
                Value = "string",
            },
        },
        CustomDimensionLabels = new[]
        {
            "string",
        },
        CustomIndicator = new Pulumi.Inputs.SLOSliCustomIndicatorArgs
        {
            TotalQueryTemplate = "string",
            BadQueryTemplate = "string",
            GoodQueryTemplate = "string",
        },
        CustomTimesliceIndicator = new Pulumi.Inputs.SLOSliCustomTimesliceIndicatorArgs
        {
            Condition = new Pulumi.Inputs.SLOSliCustomTimesliceIndicatorConditionArgs
            {
                Op = "string",
                Value = 0,
            },
            QueryTemplate = "string",
            TimesliceSize = "string",
        },
    },
    Annotations = 
    {
        { "string", "string" },
    },
    Description = "string",
    Labels = 
    {
        { "string", "string" },
    },
    NotificationPolicyId = "string",
    SignalGrouping = new Pulumi.Inputs.SLOSignalGroupingArgs
    {
        LabelNames = new[]
        {
            "string",
        },
        SignalPerSeries = false,
    },
    Slug = "string",
});

    example, err := chronosphere.NewSLO(ctx, "sloResource", &chronosphere.SLOArgs{
	CollectionId: pulumi.String("string"),
	Definition: &chronosphere.SLODefinitionArgs{
		Objective: pulumi.Float64(0),
		BurnRateAlertingConfigs: chronosphere.SLODefinitionBurnRateAlertingConfigArray{
			&chronosphere.SLODefinitionBurnRateAlertingConfigArgs{
				Budget:   pulumi.Float64(0),
				Severity: pulumi.String("string"),
				Window:   pulumi.String("string"),
				Labels: pulumi.StringMap{
					"string": pulumi.String("string"),
				},
			},
		},
		EnableBurnRateAlerting: pulumi.Bool(false),
		TimeWindow: &chronosphere.SLODefinitionTimeWindowArgs{
			Duration: pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
	Sli: &chronosphere.SLOSliArgs{
		AdditionalPromqlFilters: chronosphere.SLOSliAdditionalPromqlFilterArray{
			&chronosphere.SLOSliAdditionalPromqlFilterArgs{
				Name:  pulumi.String("string"),
				Type:  pulumi.String("string"),
				Value: pulumi.String("string"),
			},
		},
		CustomDimensionLabels: pulumi.StringArray{
			pulumi.String("string"),
		},
		CustomIndicator: &chronosphere.SLOSliCustomIndicatorArgs{
			TotalQueryTemplate: pulumi.String("string"),
			BadQueryTemplate:   pulumi.String("string"),
			GoodQueryTemplate:  pulumi.String("string"),
		},
		CustomTimesliceIndicator: &chronosphere.SLOSliCustomTimesliceIndicatorArgs{
			Condition: &chronosphere.SLOSliCustomTimesliceIndicatorConditionArgs{
				Op:    pulumi.String("string"),
				Value: pulumi.Float64(0),
			},
			QueryTemplate: pulumi.String("string"),
			TimesliceSize: pulumi.String("string"),
		},
	},
	Annotations: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Description: pulumi.String("string"),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	NotificationPolicyId: pulumi.String("string"),
	SignalGrouping: &chronosphere.SLOSignalGroupingArgs{
		LabelNames: pulumi.StringArray{
			pulumi.String("string"),
		},
		SignalPerSeries: pulumi.Bool(false),
	},
	Slug: pulumi.String("string"),
})

    resource "chronosphere_slo" "sloResource" {
  collection_id = "string"
  definition = {
    objective = 0
    burn_rate_alerting_configs = [{
      "budget"   = 0
      "severity" = "string"
      "window"   = "string"
      "labels" = {
        "string" = "string"
      }
    }]
    enable_burn_rate_alerting = false
    time_window = {
      duration = "string"
    }
  }
  name = "string"
  sli = {
    additional_promql_filters = [{
      "name"  = "string"
      "type"  = "string"
      "value" = "string"
    }]
    custom_dimension_labels = ["string"]
    custom_indicator = {
      total_query_template = "string"
      bad_query_template   = "string"
      good_query_template  = "string"
    }
    custom_timeslice_indicator = {
      condition = {
        op    = "string"
        value = 0
      }
      query_template = "string"
      timeslice_size = "string"
    }
  }
  annotations = {
    "string" = "string"
  }
  description = "string"
  labels = {
    "string" = "string"
  }
  notification_policy_id = "string"
  signal_grouping = {
    label_names       = ["string"]
    signal_per_series = false
  }
  slug = "string"
}

    var sloResource = new SLO("sloResource", SLOArgs.builder()
    .collectionId("string")
    .definition(SLODefinitionArgs.builder()
        .objective(0.0)
        .burnRateAlertingConfigs(SLODefinitionBurnRateAlertingConfigArgs.builder()
            .budget(0.0)
            .severity("string")
            .window("string")
            .labels(Map.of("string", "string"))
            .build())
        .enableBurnRateAlerting(false)
        .timeWindow(SLODefinitionTimeWindowArgs.builder()
            .duration("string")
            .build())
        .build())
    .name("string")
    .sli(SLOSliArgs.builder()
        .additionalPromqlFilters(SLOSliAdditionalPromqlFilterArgs.builder()
            .name("string")
            .type("string")
            .value("string")
            .build())
        .customDimensionLabels("string")
        .customIndicator(SLOSliCustomIndicatorArgs.builder()
            .totalQueryTemplate("string")
            .badQueryTemplate("string")
            .goodQueryTemplate("string")
            .build())
        .customTimesliceIndicator(SLOSliCustomTimesliceIndicatorArgs.builder()
            .condition(SLOSliCustomTimesliceIndicatorConditionArgs.builder()
                .op("string")
                .value(0.0)
                .build())
            .queryTemplate("string")
            .timesliceSize("string")
            .build())
        .build())
    .annotations(Map.of("string", "string"))
    .description("string")
    .labels(Map.of("string", "string"))
    .notificationPolicyId("string")
    .signalGrouping(SLOSignalGroupingArgs.builder()
        .labelNames("string")
        .signalPerSeries(false)
        .build())
    .slug("string")
    .build());

    slo_resource = chronosphere.SLO("sloResource",
    collection_id="string",
    definition={
        "objective": float(0),
        "burn_rate_alerting_configs": [{
            "budget": float(0),
            "severity": "string",
            "window": "string",
            "labels": {
                "string": "string",
            },
        }],
        "enable_burn_rate_alerting": False,
        "time_window": {
            "duration": "string",
        },
    },
    name="string",
    sli={
        "additional_promql_filters": [{
            "name": "string",
            "type": "string",
            "value": "string",
        }],
        "custom_dimension_labels": ["string"],
        "custom_indicator": {
            "total_query_template": "string",
            "bad_query_template": "string",
            "good_query_template": "string",
        },
        "custom_timeslice_indicator": {
            "condition": {
                "op": "string",
                "value": float(0),
            },
            "query_template": "string",
            "timeslice_size": "string",
        },
    },
    annotations={
        "string": "string",
    },
    description="string",
    labels={
        "string": "string",
    },
    notification_policy_id="string",
    signal_grouping={
        "label_names": ["string"],
        "signal_per_series": False,
    },
    slug="string")

    const sloResource = new chronosphere.SLO("sloResource", {
    collectionId: "string",
    definition: {
        objective: 0,
        burnRateAlertingConfigs: [{
            budget: 0,
            severity: "string",
            window: "string",
            labels: {
                string: "string",
            },
        }],
        enableBurnRateAlerting: false,
        timeWindow: {
            duration: "string",
        },
    },
    name: "string",
    sli: {
        additionalPromqlFilters: [{
            name: "string",
            type: "string",
            value: "string",
        }],
        customDimensionLabels: ["string"],
        customIndicator: {
            totalQueryTemplate: "string",
            badQueryTemplate: "string",
            goodQueryTemplate: "string",
        },
        customTimesliceIndicator: {
            condition: {
                op: "string",
                value: 0,
            },
            queryTemplate: "string",
            timesliceSize: "string",
        },
    },
    annotations: {
        string: "string",
    },
    description: "string",
    labels: {
        string: "string",
    },
    notificationPolicyId: "string",
    signalGrouping: {
        labelNames: ["string"],
        signalPerSeries: false,
    },
    slug: "string",
});

    type: chronosphere:SLO
properties:
    annotations:
        string: string
    collectionId: string
    definition:
        burnRateAlertingConfigs:
            - budget: 0
              labels:
                string: string
              severity: string
              window: string
        enableBurnRateAlerting: false
        objective: 0
        timeWindow:
            duration: string
    description: string
    labels:
        string: string
    name: string
    notificationPolicyId: string
    signalGrouping:
        labelNames:
            - string
        signalPerSeries: false
    sli:
        additionalPromqlFilters:
            - name: string
              type: string
              value: string
        customDimensionLabels:
            - string
        customIndicator:
            badQueryTemplate: string
            goodQueryTemplate: string
            totalQueryTemplate: string
        customTimesliceIndicator:
            condition:
                op: string
                value: 0
            queryTemplate: string
            timesliceSize: string
    slug: string

    SLO Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The SLO resource accepts the following input properties:

    CollectionId string
    ID of the collection that owns this SLO.
    Definition Chronosphere.Pulumi.Inputs.SLODefinition
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    Name string
    Prometheus label name to match.
    Sli Chronosphere.Pulumi.Inputs.SLOSli
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    Annotations Dictionary<string, string>
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    Description string
    Free-form description of the SLO.
    Labels Dictionary<string, string>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    NotificationPolicyId string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    SignalGrouping Chronosphere.Pulumi.Inputs.SLOSignalGrouping
    Controls how individual time series are grouped into signals for alerting purposes.
    Slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    CollectionId string
    ID of the collection that owns this SLO.
    Definition SLODefinitionArgs
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    Name string
    Prometheus label name to match.
    Sli SLOSliArgs
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    Annotations map[string]string
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    Description string
    Free-form description of the SLO.
    Labels map[string]string
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    NotificationPolicyId string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    SignalGrouping SLOSignalGroupingArgs
    Controls how individual time series are grouped into signals for alerting purposes.
    Slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    collection_id string
    ID of the collection that owns this SLO.
    definition object
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    name string
    Prometheus label name to match.
    sli object
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    annotations map(string)
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    description string
    Free-form description of the SLO.
    labels map(string)
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    notification_policy_id string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signal_grouping object
    Controls how individual time series are grouped into signals for alerting purposes.
    slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    collectionId String
    ID of the collection that owns this SLO.
    definition SLODefinition
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    name String
    Prometheus label name to match.
    sli SLOSli
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    annotations Map<String,String>
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    description String
    Free-form description of the SLO.
    labels Map<String,String>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    notificationPolicyId String
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signalGrouping SLOSignalGrouping
    Controls how individual time series are grouped into signals for alerting purposes.
    slug String
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    collectionId string
    ID of the collection that owns this SLO.
    definition SLODefinition
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    name string
    Prometheus label name to match.
    sli SLOSli
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    annotations {[key: string]: string}
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    description string
    Free-form description of the SLO.
    labels {[key: string]: string}
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    notificationPolicyId string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signalGrouping SLOSignalGrouping
    Controls how individual time series are grouped into signals for alerting purposes.
    slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    collection_id str
    ID of the collection that owns this SLO.
    definition SLODefinitionArgs
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    name str
    Prometheus label name to match.
    sli SLOSliArgs
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    annotations Mapping[str, str]
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    description str
    Free-form description of the SLO.
    labels Mapping[str, str]
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    notification_policy_id str
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signal_grouping SLOSignalGroupingArgs
    Controls how individual time series are grouped into signals for alerting purposes.
    slug str
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    collectionId String
    ID of the collection that owns this SLO.
    definition Property Map
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    name String
    Prometheus label name to match.
    sli Property Map
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    annotations Map<String>
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    description String
    Free-form description of the SLO.
    labels Map<String>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    notificationPolicyId String
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signalGrouping Property Map
    Controls how individual time series are grouped into signals for alerting purposes.
    slug String
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the SLO resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing SLO Resource

    Get an existing SLO resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: SLOState, opts?: CustomResourceOptions): SLO
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        annotations: Optional[Mapping[str, str]] = None,
        collection_id: Optional[str] = None,
        definition: Optional[SLODefinitionArgs] = None,
        description: Optional[str] = None,
        labels: Optional[Mapping[str, str]] = None,
        name: Optional[str] = None,
        notification_policy_id: Optional[str] = None,
        signal_grouping: Optional[SLOSignalGroupingArgs] = None,
        sli: Optional[SLOSliArgs] = None,
        slug: Optional[str] = None) -> SLO
    func GetSLO(ctx *Context, name string, id IDInput, state *SLOState, opts ...ResourceOption) (*SLO, error)
    public static SLO Get(string name, Input<string> id, SLOState? state, CustomResourceOptions? opts = null)
    public static SLO get(String name, Output<String> id, SLOState state, CustomResourceOptions options)
    resources:  _:    type: chronosphere:SLO    get:      id: ${id}
    import {
  to = chronosphere_slo.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Annotations Dictionary<string, string>
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    CollectionId string
    ID of the collection that owns this SLO.
    Definition Chronosphere.Pulumi.Inputs.SLODefinition
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    Description string
    Free-form description of the SLO.
    Labels Dictionary<string, string>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    Name string
    Prometheus label name to match.
    NotificationPolicyId string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    SignalGrouping Chronosphere.Pulumi.Inputs.SLOSignalGrouping
    Controls how individual time series are grouped into signals for alerting purposes.
    Sli Chronosphere.Pulumi.Inputs.SLOSli
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    Slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    Annotations map[string]string
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    CollectionId string
    ID of the collection that owns this SLO.
    Definition SLODefinitionArgs
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    Description string
    Free-form description of the SLO.
    Labels map[string]string
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    Name string
    Prometheus label name to match.
    NotificationPolicyId string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    SignalGrouping SLOSignalGroupingArgs
    Controls how individual time series are grouped into signals for alerting purposes.
    Sli SLOSliArgs
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    Slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    annotations map(string)
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    collection_id string
    ID of the collection that owns this SLO.
    definition object
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    description string
    Free-form description of the SLO.
    labels map(string)
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    name string
    Prometheus label name to match.
    notification_policy_id string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signal_grouping object
    Controls how individual time series are grouped into signals for alerting purposes.
    sli object
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    annotations Map<String,String>
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    collectionId String
    ID of the collection that owns this SLO.
    definition SLODefinition
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    description String
    Free-form description of the SLO.
    labels Map<String,String>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    name String
    Prometheus label name to match.
    notificationPolicyId String
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signalGrouping SLOSignalGrouping
    Controls how individual time series are grouped into signals for alerting purposes.
    sli SLOSli
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    slug String
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    annotations {[key: string]: string}
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    collectionId string
    ID of the collection that owns this SLO.
    definition SLODefinition
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    description string
    Free-form description of the SLO.
    labels {[key: string]: string}
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    name string
    Prometheus label name to match.
    notificationPolicyId string
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signalGrouping SLOSignalGrouping
    Controls how individual time series are grouped into signals for alerting purposes.
    sli SLOSli
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    slug string
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    annotations Mapping[str, str]
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    collection_id str
    ID of the collection that owns this SLO.
    definition SLODefinitionArgs
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    description str
    Free-form description of the SLO.
    labels Mapping[str, str]
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    name str
    Prometheus label name to match.
    notification_policy_id str
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signal_grouping SLOSignalGroupingArgs
    Controls how individual time series are grouped into signals for alerting purposes.
    sli SLOSliArgs
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    slug str
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.
    annotations Map<String>
    Free-form key/value pairs included in notifications generated by this SLO. Templated against signal labels.
    collectionId String
    ID of the collection that owns this SLO.
    definition Property Map
    SLO definition specifying the objective, time window, and burn-rate alerting configuration.
    description String
    Free-form description of the SLO.
    labels Map<String>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    name String
    Prometheus label name to match.
    notificationPolicyId String
    ID of the notification policy used to route burn-rate alerts from this SLO. If omitted, the policy of the parent collection applies. Required if burn-rate alerting is enabled and the collection has no default policy.
    signalGrouping Property Map
    Controls how individual time series are grouped into signals for alerting purposes.
    sli Property Map
    Service-level indicator (SLI) definition that produces the good/bad event ratio measured by this SLO.
    slug String
    Stable identifier for the SLO. Generated from name if omitted. Immutable after creation.

    Supporting Types

    SLODefinition, SLODefinitionArgs

    Objective double
    Target SLO percentage representing the desired availability (e.g. 99.9).
    BurnRateAlertingConfigs List<Chronosphere.Pulumi.Inputs.SLODefinitionBurnRateAlertingConfig>
    Custom burn-rate alert definitions. If omitted, the system default burn rates are used. Only takes effect when enable_burn_rate_alerting is true.
    EnableBurnRateAlerting bool
    Whether burn-rate alerting is enabled for this SLO.
    TimeWindow Chronosphere.Pulumi.Inputs.SLODefinitionTimeWindow
    Rolling time window over which the SLO objective is evaluated.
    Objective float64
    Target SLO percentage representing the desired availability (e.g. 99.9).
    BurnRateAlertingConfigs []SLODefinitionBurnRateAlertingConfig
    Custom burn-rate alert definitions. If omitted, the system default burn rates are used. Only takes effect when enable_burn_rate_alerting is true.
    EnableBurnRateAlerting bool
    Whether burn-rate alerting is enabled for this SLO.
    TimeWindow SLODefinitionTimeWindow
    Rolling time window over which the SLO objective is evaluated.
    objective number
    Target SLO percentage representing the desired availability (e.g. 99.9).
    burn_rate_alerting_configs list(object)
    Custom burn-rate alert definitions. If omitted, the system default burn rates are used. Only takes effect when enable_burn_rate_alerting is true.
    enable_burn_rate_alerting bool
    Whether burn-rate alerting is enabled for this SLO.
    time_window object
    Rolling time window over which the SLO objective is evaluated.
    objective Double
    Target SLO percentage representing the desired availability (e.g. 99.9).
    burnRateAlertingConfigs List<SLODefinitionBurnRateAlertingConfig>
    Custom burn-rate alert definitions. If omitted, the system default burn rates are used. Only takes effect when enable_burn_rate_alerting is true.
    enableBurnRateAlerting Boolean
    Whether burn-rate alerting is enabled for this SLO.
    timeWindow SLODefinitionTimeWindow
    Rolling time window over which the SLO objective is evaluated.
    objective number
    Target SLO percentage representing the desired availability (e.g. 99.9).
    burnRateAlertingConfigs SLODefinitionBurnRateAlertingConfig[]
    Custom burn-rate alert definitions. If omitted, the system default burn rates are used. Only takes effect when enable_burn_rate_alerting is true.
    enableBurnRateAlerting boolean
    Whether burn-rate alerting is enabled for this SLO.
    timeWindow SLODefinitionTimeWindow
    Rolling time window over which the SLO objective is evaluated.
    objective float
    Target SLO percentage representing the desired availability (e.g. 99.9).
    burn_rate_alerting_configs Sequence[SLODefinitionBurnRateAlertingConfig]
    Custom burn-rate alert definitions. If omitted, the system default burn rates are used. Only takes effect when enable_burn_rate_alerting is true.
    enable_burn_rate_alerting bool
    Whether burn-rate alerting is enabled for this SLO.
    time_window SLODefinitionTimeWindow
    Rolling time window over which the SLO objective is evaluated.
    objective Number
    Target SLO percentage representing the desired availability (e.g. 99.9).
    burnRateAlertingConfigs List<Property Map>
    Custom burn-rate alert definitions. If omitted, the system default burn rates are used. Only takes effect when enable_burn_rate_alerting is true.
    enableBurnRateAlerting Boolean
    Whether burn-rate alerting is enabled for this SLO.
    timeWindow Property Map
    Rolling time window over which the SLO objective is evaluated.

    SLODefinitionBurnRateAlertingConfig, SLODefinitionBurnRateAlertingConfigArgs

    Budget double
    Percentage of the error budget that can be consumed during window before the alert fires. Must be between 0.0 and 100.0 exclusive.
    Severity string
    Severity assigned when the burn rate fires. Must be critical or warn.
    Window string
    Time window for the burn-rate calculation (e.g. 1h, 6h).
    Labels Dictionary<string, string>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    Budget float64
    Percentage of the error budget that can be consumed during window before the alert fires. Must be between 0.0 and 100.0 exclusive.
    Severity string
    Severity assigned when the burn rate fires. Must be critical or warn.
    Window string
    Time window for the burn-rate calculation (e.g. 1h, 6h).
    Labels map[string]string
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    budget number
    Percentage of the error budget that can be consumed during window before the alert fires. Must be between 0.0 and 100.0 exclusive.
    severity string
    Severity assigned when the burn rate fires. Must be critical or warn.
    window string
    Time window for the burn-rate calculation (e.g. 1h, 6h).
    labels map(string)
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    budget Double
    Percentage of the error budget that can be consumed during window before the alert fires. Must be between 0.0 and 100.0 exclusive.
    severity String
    Severity assigned when the burn rate fires. Must be critical or warn.
    window String
    Time window for the burn-rate calculation (e.g. 1h, 6h).
    labels Map<String,String>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    budget number
    Percentage of the error budget that can be consumed during window before the alert fires. Must be between 0.0 and 100.0 exclusive.
    severity string
    Severity assigned when the burn rate fires. Must be critical or warn.
    window string
    Time window for the burn-rate calculation (e.g. 1h, 6h).
    labels {[key: string]: string}
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    budget float
    Percentage of the error budget that can be consumed during window before the alert fires. Must be between 0.0 and 100.0 exclusive.
    severity str
    Severity assigned when the burn rate fires. Must be critical or warn.
    window str
    Time window for the burn-rate calculation (e.g. 1h, 6h).
    labels Mapping[str, str]
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.
    budget Number
    Percentage of the error budget that can be consumed during window before the alert fires. Must be between 0.0 and 100.0 exclusive.
    severity String
    Severity assigned when the burn rate fires. Must be critical or warn.
    window String
    Time window for the burn-rate calculation (e.g. 1h, 6h).
    labels Map<String>
    Additional labels attached when this burn-rate alert fires. Can be used by notification policies to route different burn rates to different destinations.

    SLODefinitionTimeWindow, SLODefinitionTimeWindowArgs

    Duration string
    Length of the evaluation window (e.g. 28d, 24h).
    Duration string
    Length of the evaluation window (e.g. 28d, 24h).
    duration string
    Length of the evaluation window (e.g. 28d, 24h).
    duration String
    Length of the evaluation window (e.g. 28d, 24h).
    duration string
    Length of the evaluation window (e.g. 28d, 24h).
    duration str
    Length of the evaluation window (e.g. 28d, 24h).
    duration String
    Length of the evaluation window (e.g. 28d, 24h).

    SLOSignalGrouping, SLOSignalGroupingArgs

    LabelNames List<string>
    Labels to group by. Series sharing the same values for these labels produce one signal. Defaults to no grouping (one signal per series).
    SignalPerSeries bool
    If true, treat each individual series as its own signal. Mutually exclusive with label_names.
    LabelNames []string
    Labels to group by. Series sharing the same values for these labels produce one signal. Defaults to no grouping (one signal per series).
    SignalPerSeries bool
    If true, treat each individual series as its own signal. Mutually exclusive with label_names.
    label_names list(string)
    Labels to group by. Series sharing the same values for these labels produce one signal. Defaults to no grouping (one signal per series).
    signal_per_series bool
    If true, treat each individual series as its own signal. Mutually exclusive with label_names.
    labelNames List<String>
    Labels to group by. Series sharing the same values for these labels produce one signal. Defaults to no grouping (one signal per series).
    signalPerSeries Boolean
    If true, treat each individual series as its own signal. Mutually exclusive with label_names.
    labelNames string[]
    Labels to group by. Series sharing the same values for these labels produce one signal. Defaults to no grouping (one signal per series).
    signalPerSeries boolean
    If true, treat each individual series as its own signal. Mutually exclusive with label_names.
    label_names Sequence[str]
    Labels to group by. Series sharing the same values for these labels produce one signal. Defaults to no grouping (one signal per series).
    signal_per_series bool
    If true, treat each individual series as its own signal. Mutually exclusive with label_names.
    labelNames List<String>
    Labels to group by. Series sharing the same values for these labels produce one signal. Defaults to no grouping (one signal per series).
    signalPerSeries Boolean
    If true, treat each individual series as its own signal. Mutually exclusive with label_names.

    SLOSli, SLOSliArgs

    AdditionalPromqlFilters List<Chronosphere.Pulumi.Inputs.SLOSliAdditionalPromqlFilter>
    Additional PromQL label matchers applied to SLI queries via the {{.AdditionalFilters}} template variable. Used to narrow the metrics scope.
    CustomDimensionLabels List<string>
    Additional labels exported from the underlying queries to group the error budget by. Available in PromQL templates via {{.GroupBy}}.
    CustomIndicator Chronosphere.Pulumi.Inputs.SLOSliCustomIndicator
    Error-ratio SLI defined by good/bad/total PromQL query templates. Mutually exclusive with custom_timeslice_indicator.
    CustomTimesliceIndicator Chronosphere.Pulumi.Inputs.SLOSliCustomTimesliceIndicator
    Time-slice SLI that evaluates a PromQL query over fixed time slices against a threshold condition. Mutually exclusive with custom_indicator.
    AdditionalPromqlFilters []SLOSliAdditionalPromqlFilter
    Additional PromQL label matchers applied to SLI queries via the {{.AdditionalFilters}} template variable. Used to narrow the metrics scope.
    CustomDimensionLabels []string
    Additional labels exported from the underlying queries to group the error budget by. Available in PromQL templates via {{.GroupBy}}.
    CustomIndicator SLOSliCustomIndicator
    Error-ratio SLI defined by good/bad/total PromQL query templates. Mutually exclusive with custom_timeslice_indicator.
    CustomTimesliceIndicator SLOSliCustomTimesliceIndicator
    Time-slice SLI that evaluates a PromQL query over fixed time slices against a threshold condition. Mutually exclusive with custom_indicator.
    additional_promql_filters list(object)
    Additional PromQL label matchers applied to SLI queries via the {{.AdditionalFilters}} template variable. Used to narrow the metrics scope.
    custom_dimension_labels list(string)
    Additional labels exported from the underlying queries to group the error budget by. Available in PromQL templates via {{.GroupBy}}.
    custom_indicator object
    Error-ratio SLI defined by good/bad/total PromQL query templates. Mutually exclusive with custom_timeslice_indicator.
    custom_timeslice_indicator object
    Time-slice SLI that evaluates a PromQL query over fixed time slices against a threshold condition. Mutually exclusive with custom_indicator.
    additionalPromqlFilters List<SLOSliAdditionalPromqlFilter>
    Additional PromQL label matchers applied to SLI queries via the {{.AdditionalFilters}} template variable. Used to narrow the metrics scope.
    customDimensionLabels List<String>
    Additional labels exported from the underlying queries to group the error budget by. Available in PromQL templates via {{.GroupBy}}.
    customIndicator SLOSliCustomIndicator
    Error-ratio SLI defined by good/bad/total PromQL query templates. Mutually exclusive with custom_timeslice_indicator.
    customTimesliceIndicator SLOSliCustomTimesliceIndicator
    Time-slice SLI that evaluates a PromQL query over fixed time slices against a threshold condition. Mutually exclusive with custom_indicator.
    additionalPromqlFilters SLOSliAdditionalPromqlFilter[]
    Additional PromQL label matchers applied to SLI queries via the {{.AdditionalFilters}} template variable. Used to narrow the metrics scope.
    customDimensionLabels string[]
    Additional labels exported from the underlying queries to group the error budget by. Available in PromQL templates via {{.GroupBy}}.
    customIndicator SLOSliCustomIndicator
    Error-ratio SLI defined by good/bad/total PromQL query templates. Mutually exclusive with custom_timeslice_indicator.
    customTimesliceIndicator SLOSliCustomTimesliceIndicator
    Time-slice SLI that evaluates a PromQL query over fixed time slices against a threshold condition. Mutually exclusive with custom_indicator.
    additional_promql_filters Sequence[SLOSliAdditionalPromqlFilter]
    Additional PromQL label matchers applied to SLI queries via the {{.AdditionalFilters}} template variable. Used to narrow the metrics scope.
    custom_dimension_labels Sequence[str]
    Additional labels exported from the underlying queries to group the error budget by. Available in PromQL templates via {{.GroupBy}}.
    custom_indicator SLOSliCustomIndicator
    Error-ratio SLI defined by good/bad/total PromQL query templates. Mutually exclusive with custom_timeslice_indicator.
    custom_timeslice_indicator SLOSliCustomTimesliceIndicator
    Time-slice SLI that evaluates a PromQL query over fixed time slices against a threshold condition. Mutually exclusive with custom_indicator.
    additionalPromqlFilters List<Property Map>
    Additional PromQL label matchers applied to SLI queries via the {{.AdditionalFilters}} template variable. Used to narrow the metrics scope.
    customDimensionLabels List<String>
    Additional labels exported from the underlying queries to group the error budget by. Available in PromQL templates via {{.GroupBy}}.
    customIndicator Property Map
    Error-ratio SLI defined by good/bad/total PromQL query templates. Mutually exclusive with custom_timeslice_indicator.
    customTimesliceIndicator Property Map
    Time-slice SLI that evaluates a PromQL query over fixed time slices against a threshold condition. Mutually exclusive with custom_indicator.

    SLOSliAdditionalPromqlFilter, SLOSliAdditionalPromqlFilterArgs

    Name string
    Prometheus label name to match.
    Type string
    Matcher type (e.g. =, !=, =~, !~).
    Value string
    Label value to match against using the chosen matcher type.
    Name string
    Prometheus label name to match.
    Type string
    Matcher type (e.g. =, !=, =~, !~).
    Value string
    Label value to match against using the chosen matcher type.
    name string
    Prometheus label name to match.
    type string
    Matcher type (e.g. =, !=, =~, !~).
    value string
    Label value to match against using the chosen matcher type.
    name String
    Prometheus label name to match.
    type String
    Matcher type (e.g. =, !=, =~, !~).
    value String
    Label value to match against using the chosen matcher type.
    name string
    Prometheus label name to match.
    type string
    Matcher type (e.g. =, !=, =~, !~).
    value string
    Label value to match against using the chosen matcher type.
    name str
    Prometheus label name to match.
    type str
    Matcher type (e.g. =, !=, =~, !~).
    value str
    Label value to match against using the chosen matcher type.
    name String
    Prometheus label name to match.
    type String
    Matcher type (e.g. =, !=, =~, !~).
    value String
    Label value to match against using the chosen matcher type.

    SLOSliCustomIndicator, SLOSliCustomIndicatorArgs

    TotalQueryTemplate string
    PromQL query template measuring the total count of events. Required for error-ratio SLOs.
    BadQueryTemplate string
    PromQL query template measuring the count of bad events. Mutually exclusive with good_query_template.
    GoodQueryTemplate string
    PromQL query template measuring the count of good events. Mutually exclusive with bad_query_template.
    TotalQueryTemplate string
    PromQL query template measuring the total count of events. Required for error-ratio SLOs.
    BadQueryTemplate string
    PromQL query template measuring the count of bad events. Mutually exclusive with good_query_template.
    GoodQueryTemplate string
    PromQL query template measuring the count of good events. Mutually exclusive with bad_query_template.
    total_query_template string
    PromQL query template measuring the total count of events. Required for error-ratio SLOs.
    bad_query_template string
    PromQL query template measuring the count of bad events. Mutually exclusive with good_query_template.
    good_query_template string
    PromQL query template measuring the count of good events. Mutually exclusive with bad_query_template.
    totalQueryTemplate String
    PromQL query template measuring the total count of events. Required for error-ratio SLOs.
    badQueryTemplate String
    PromQL query template measuring the count of bad events. Mutually exclusive with good_query_template.
    goodQueryTemplate String
    PromQL query template measuring the count of good events. Mutually exclusive with bad_query_template.
    totalQueryTemplate string
    PromQL query template measuring the total count of events. Required for error-ratio SLOs.
    badQueryTemplate string
    PromQL query template measuring the count of bad events. Mutually exclusive with good_query_template.
    goodQueryTemplate string
    PromQL query template measuring the count of good events. Mutually exclusive with bad_query_template.
    total_query_template str
    PromQL query template measuring the total count of events. Required for error-ratio SLOs.
    bad_query_template str
    PromQL query template measuring the count of bad events. Mutually exclusive with good_query_template.
    good_query_template str
    PromQL query template measuring the count of good events. Mutually exclusive with bad_query_template.
    totalQueryTemplate String
    PromQL query template measuring the total count of events. Required for error-ratio SLOs.
    badQueryTemplate String
    PromQL query template measuring the count of bad events. Mutually exclusive with good_query_template.
    goodQueryTemplate String
    PromQL query template measuring the count of good events. Mutually exclusive with bad_query_template.

    SLOSliCustomTimesliceIndicator, SLOSliCustomTimesliceIndicatorArgs

    Condition Chronosphere.Pulumi.Inputs.SLOSliCustomTimesliceIndicatorCondition
    Condition used to classify each time slice as good or bad based on the query result.
    QueryTemplate string
    PromQL query template evaluated against each time slice.
    TimesliceSize string
    Size of each time slice evaluated by the query (e.g. 1m, 5m).
    Condition SLOSliCustomTimesliceIndicatorCondition
    Condition used to classify each time slice as good or bad based on the query result.
    QueryTemplate string
    PromQL query template evaluated against each time slice.
    TimesliceSize string
    Size of each time slice evaluated by the query (e.g. 1m, 5m).
    condition object
    Condition used to classify each time slice as good or bad based on the query result.
    query_template string
    PromQL query template evaluated against each time slice.
    timeslice_size string
    Size of each time slice evaluated by the query (e.g. 1m, 5m).
    condition SLOSliCustomTimesliceIndicatorCondition
    Condition used to classify each time slice as good or bad based on the query result.
    queryTemplate String
    PromQL query template evaluated against each time slice.
    timesliceSize String
    Size of each time slice evaluated by the query (e.g. 1m, 5m).
    condition SLOSliCustomTimesliceIndicatorCondition
    Condition used to classify each time slice as good or bad based on the query result.
    queryTemplate string
    PromQL query template evaluated against each time slice.
    timesliceSize string
    Size of each time slice evaluated by the query (e.g. 1m, 5m).
    condition SLOSliCustomTimesliceIndicatorCondition
    Condition used to classify each time slice as good or bad based on the query result.
    query_template str
    PromQL query template evaluated against each time slice.
    timeslice_size str
    Size of each time slice evaluated by the query (e.g. 1m, 5m).
    condition Property Map
    Condition used to classify each time slice as good or bad based on the query result.
    queryTemplate String
    PromQL query template evaluated against each time slice.
    timesliceSize String
    Size of each time slice evaluated by the query (e.g. 1m, 5m).

    SLOSliCustomTimesliceIndicatorCondition, SLOSliCustomTimesliceIndicatorConditionArgs

    Op string
    Comparison operator between the query value and value (e.g. gt, lt, eq).
    Value double
    Label value to match against using the chosen matcher type.
    Op string
    Comparison operator between the query value and value (e.g. gt, lt, eq).
    Value float64
    Label value to match against using the chosen matcher type.
    op string
    Comparison operator between the query value and value (e.g. gt, lt, eq).
    value number
    Label value to match against using the chosen matcher type.
    op String
    Comparison operator between the query value and value (e.g. gt, lt, eq).
    value Double
    Label value to match against using the chosen matcher type.
    op string
    Comparison operator between the query value and value (e.g. gt, lt, eq).
    value number
    Label value to match against using the chosen matcher type.
    op str
    Comparison operator between the query value and value (e.g. gt, lt, eq).
    value float
    Label value to match against using the chosen matcher type.
    op String
    Comparison operator between the query value and value (e.g. gt, lt, eq).
    value Number
    Label value to match against using the chosen matcher type.

    Package Details

    Repository
    chronosphere chronosphereio/pulumi-chronosphere
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the chronosphere Terraform Provider.
    Viewing docs for Chronosphere v0.9.16
    published on Friday, Jun 5, 2026 by Chronosphere
    Schema (JSON)
    chronosphereio/pulumi-chronosphere

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial