datadog.ServiceLevelObjective

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

// Metric-Based SLO
// Create a new Datadog service level objective
const foo = new datadog.ServiceLevelObjective("foo", {
    name: "Example Metric SLO",
    type: "metric",
    description: "My custom metric SLO",
    query: {
        numerator: "sum:my.custom.count.metric{type:good_events}.as_count()",
        denominator: "sum:my.custom.count.metric{*}.as_count()",
    },
    thresholds: [
        {
            timeframe: "7d",
            target: 99.9,
            warning: 99.99,
        },
        {
            timeframe: "30d",
            target: 99.9,
            warning: 99.99,
        },
    ],
    timeframe: "30d",
    targetThreshold: 99.9,
    warningThreshold: 99.99,
    tags: [
        "foo:bar",
        "baz",
    ],
});
// Monitor-Based SLO
// Create a new Datadog service level objective
const bar = new datadog.ServiceLevelObjective("bar", {
    name: "Example Monitor SLO",
    type: "monitor",
    description: "My custom monitor SLO",
    monitorIds: [
        1,
        2,
        3,
    ],
    thresholds: [
        {
            timeframe: "7d",
            target: 99.9,
            warning: 99.99,
        },
        {
            timeframe: "30d",
            target: 99.9,
            warning: 99.99,
        },
    ],
    timeframe: "30d",
    targetThreshold: 99.9,
    warningThreshold: 99.99,
    tags: [
        "foo:bar",
        "baz",
    ],
});
const timeSliceSlo = new datadog.ServiceLevelObjective("time_slice_slo", {
    name: "Example Time Slice SLO",
    type: "time_slice",
    description: "My custom time slice SLO",
    sliSpecification: {
        timeSlice: {
            query: {
                formula: {
                    formulaExpression: "query1",
                },
                queries: [{
                    metricQuery: {
                        name: "query1",
                        query: "avg:my.custom.count.metric{*}.as_count()",
                    },
                }],
            },
            comparator: ">",
            threshold: 0.9,
        },
    },
    thresholds: [{
        timeframe: "7d",
        target: 99.9,
        warning: 99.99,
    }],
    timeframe: "7d",
    targetThreshold: 99.9,
    warningThreshold: 99.99,
    tags: [
        "service:myservice",
        "team:myteam",
    ],
});

import pulumi
import pulumi_datadog as datadog

# Metric-Based SLO
# Create a new Datadog service level objective
foo = datadog.ServiceLevelObjective("foo",
    name="Example Metric SLO",
    type="metric",
    description="My custom metric SLO",
    query={
        "numerator": "sum:my.custom.count.metric{type:good_events}.as_count()",
        "denominator": "sum:my.custom.count.metric{*}.as_count()",
    },
    thresholds=[
        {
            "timeframe": "7d",
            "target": 99.9,
            "warning": 99.99,
        },
        {
            "timeframe": "30d",
            "target": 99.9,
            "warning": 99.99,
        },
    ],
    timeframe="30d",
    target_threshold=99.9,
    warning_threshold=99.99,
    tags=[
        "foo:bar",
        "baz",
    ])
# Monitor-Based SLO
# Create a new Datadog service level objective
bar = datadog.ServiceLevelObjective("bar",
    name="Example Monitor SLO",
    type="monitor",
    description="My custom monitor SLO",
    monitor_ids=[
        1,
        2,
        3,
    ],
    thresholds=[
        {
            "timeframe": "7d",
            "target": 99.9,
            "warning": 99.99,
        },
        {
            "timeframe": "30d",
            "target": 99.9,
            "warning": 99.99,
        },
    ],
    timeframe="30d",
    target_threshold=99.9,
    warning_threshold=99.99,
    tags=[
        "foo:bar",
        "baz",
    ])
time_slice_slo = datadog.ServiceLevelObjective("time_slice_slo",
    name="Example Time Slice SLO",
    type="time_slice",
    description="My custom time slice SLO",
    sli_specification={
        "time_slice": {
            "query": {
                "formula": {
                    "formula_expression": "query1",
                },
                "queries": [{
                    "metric_query": {
                        "name": "query1",
                        "query": "avg:my.custom.count.metric{*}.as_count()",
                    },
                }],
            },
            "comparator": ">",
            "threshold": 0.9,
        },
    },
    thresholds=[{
        "timeframe": "7d",
        "target": 99.9,
        "warning": 99.99,
    }],
    timeframe="7d",
    target_threshold=99.9,
    warning_threshold=99.99,
    tags=[
        "service:myservice",
        "team:myteam",
    ])

package main

import (
	"github.com/pulumi/pulumi-datadog/sdk/v4/go/datadog"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Metric-Based SLO
		// Create a new Datadog service level objective
		_, err := datadog.NewServiceLevelObjective(ctx, "foo", &datadog.ServiceLevelObjectiveArgs{
			Name:        pulumi.String("Example Metric SLO"),
			Type:        pulumi.String("metric"),
			Description: pulumi.String("My custom metric SLO"),
			Query: &datadog.ServiceLevelObjectiveQueryArgs{
				Numerator:   pulumi.String("sum:my.custom.count.metric{type:good_events}.as_count()"),
				Denominator: pulumi.String("sum:my.custom.count.metric{*}.as_count()"),
			},
			Thresholds: datadog.ServiceLevelObjectiveThresholdArray{
				&datadog.ServiceLevelObjectiveThresholdArgs{
					Timeframe: pulumi.String("7d"),
					Target:    pulumi.Float64(99.9),
					Warning:   pulumi.Float64(99.99),
				},
				&datadog.ServiceLevelObjectiveThresholdArgs{
					Timeframe: pulumi.String("30d"),
					Target:    pulumi.Float64(99.9),
					Warning:   pulumi.Float64(99.99),
				},
			},
			Timeframe:        pulumi.String("30d"),
			TargetThreshold:  pulumi.Float64(99.9),
			WarningThreshold: pulumi.Float64(99.99),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("baz"),
			},
		})
		if err != nil {
			return err
		}
		// Monitor-Based SLO
		// Create a new Datadog service level objective
		_, err = datadog.NewServiceLevelObjective(ctx, "bar", &datadog.ServiceLevelObjectiveArgs{
			Name:        pulumi.String("Example Monitor SLO"),
			Type:        pulumi.String("monitor"),
			Description: pulumi.String("My custom monitor SLO"),
			MonitorIds: pulumi.IntArray{
				pulumi.Int(1),
				pulumi.Int(2),
				pulumi.Int(3),
			},
			Thresholds: datadog.ServiceLevelObjectiveThresholdArray{
				&datadog.ServiceLevelObjectiveThresholdArgs{
					Timeframe: pulumi.String("7d"),
					Target:    pulumi.Float64(99.9),
					Warning:   pulumi.Float64(99.99),
				},
				&datadog.ServiceLevelObjectiveThresholdArgs{
					Timeframe: pulumi.String("30d"),
					Target:    pulumi.Float64(99.9),
					Warning:   pulumi.Float64(99.99),
				},
			},
			Timeframe:        pulumi.String("30d"),
			TargetThreshold:  pulumi.Float64(99.9),
			WarningThreshold: pulumi.Float64(99.99),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("baz"),
			},
		})
		if err != nil {
			return err
		}
		_, err = datadog.NewServiceLevelObjective(ctx, "time_slice_slo", &datadog.ServiceLevelObjectiveArgs{
			Name:        pulumi.String("Example Time Slice SLO"),
			Type:        pulumi.String("time_slice"),
			Description: pulumi.String("My custom time slice SLO"),
			SliSpecification: &datadog.ServiceLevelObjectiveSliSpecificationArgs{
				TimeSlice: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceArgs{
					Query: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryArgs{
						Formula: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryFormulaArgs{
							FormulaExpression: pulumi.String("query1"),
						},
						Queries: datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArray{
							&datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArgs{
								MetricQuery: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryMetricQueryArgs{
									Name:  pulumi.String("query1"),
									Query: pulumi.String("avg:my.custom.count.metric{*}.as_count()"),
								},
							},
						},
					},
					Comparator: pulumi.String(">"),
					Threshold:  pulumi.Float64(0.9),
				},
			},
			Thresholds: datadog.ServiceLevelObjectiveThresholdArray{
				&datadog.ServiceLevelObjectiveThresholdArgs{
					Timeframe: pulumi.String("7d"),
					Target:    pulumi.Float64(99.9),
					Warning:   pulumi.Float64(99.99),
				},
			},
			Timeframe:        pulumi.String("7d"),
			TargetThreshold:  pulumi.Float64(99.9),
			WarningThreshold: pulumi.Float64(99.99),
			Tags: pulumi.StringArray{
				pulumi.String("service:myservice"),
				pulumi.String("team:myteam"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Metric-Based SLO
    // Create a new Datadog service level objective
    var foo = new Datadog.ServiceLevelObjective("foo", new()
    {
        Name = "Example Metric SLO",
        Type = "metric",
        Description = "My custom metric SLO",
        Query = new Datadog.Inputs.ServiceLevelObjectiveQueryArgs
        {
            Numerator = "sum:my.custom.count.metric{type:good_events}.as_count()",
            Denominator = "sum:my.custom.count.metric{*}.as_count()",
        },
        Thresholds = new[]
        {
            new Datadog.Inputs.ServiceLevelObjectiveThresholdArgs
            {
                Timeframe = "7d",
                Target = 99.9,
                Warning = 99.99,
            },
            new Datadog.Inputs.ServiceLevelObjectiveThresholdArgs
            {
                Timeframe = "30d",
                Target = 99.9,
                Warning = 99.99,
            },
        },
        Timeframe = "30d",
        TargetThreshold = 99.9,
        WarningThreshold = 99.99,
        Tags = new[]
        {
            "foo:bar",
            "baz",
        },
    });

    // Monitor-Based SLO
    // Create a new Datadog service level objective
    var bar = new Datadog.ServiceLevelObjective("bar", new()
    {
        Name = "Example Monitor SLO",
        Type = "monitor",
        Description = "My custom monitor SLO",
        MonitorIds = new[]
        {
            1,
            2,
            3,
        },
        Thresholds = new[]
        {
            new Datadog.Inputs.ServiceLevelObjectiveThresholdArgs
            {
                Timeframe = "7d",
                Target = 99.9,
                Warning = 99.99,
            },
            new Datadog.Inputs.ServiceLevelObjectiveThresholdArgs
            {
                Timeframe = "30d",
                Target = 99.9,
                Warning = 99.99,
            },
        },
        Timeframe = "30d",
        TargetThreshold = 99.9,
        WarningThreshold = 99.99,
        Tags = new[]
        {
            "foo:bar",
            "baz",
        },
    });

    var timeSliceSlo = new Datadog.ServiceLevelObjective("time_slice_slo", new()
    {
        Name = "Example Time Slice SLO",
        Type = "time_slice",
        Description = "My custom time slice SLO",
        SliSpecification = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationArgs
        {
            TimeSlice = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceArgs
            {
                Query = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryArgs
                {
                    Formula = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryFormulaArgs
                    {
                        FormulaExpression = "query1",
                    },
                    Queries = new[]
                    {
                        new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArgs
                        {
                            MetricQuery = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryMetricQueryArgs
                            {
                                Name = "query1",
                                Query = "avg:my.custom.count.metric{*}.as_count()",
                            },
                        },
                    },
                },
                Comparator = ">",
                Threshold = 0.9,
            },
        },
        Thresholds = new[]
        {
            new Datadog.Inputs.ServiceLevelObjectiveThresholdArgs
            {
                Timeframe = "7d",
                Target = 99.9,
                Warning = 99.99,
            },
        },
        Timeframe = "7d",
        TargetThreshold = 99.9,
        WarningThreshold = 99.99,
        Tags = new[]
        {
            "service:myservice",
            "team:myteam",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.datadog.ServiceLevelObjective;
import com.pulumi.datadog.ServiceLevelObjectiveArgs;
import com.pulumi.datadog.inputs.ServiceLevelObjectiveQueryArgs;
import com.pulumi.datadog.inputs.ServiceLevelObjectiveThresholdArgs;
import com.pulumi.datadog.inputs.ServiceLevelObjectiveSliSpecificationArgs;
import com.pulumi.datadog.inputs.ServiceLevelObjectiveSliSpecificationTimeSliceArgs;
import com.pulumi.datadog.inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryArgs;
import com.pulumi.datadog.inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryFormulaArgs;
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) {
        // Metric-Based SLO
        // Create a new Datadog service level objective
        var foo = new ServiceLevelObjective("foo", ServiceLevelObjectiveArgs.builder()
            .name("Example Metric SLO")
            .type("metric")
            .description("My custom metric SLO")
            .query(ServiceLevelObjectiveQueryArgs.builder()
                .numerator("sum:my.custom.count.metric{type:good_events}.as_count()")
                .denominator("sum:my.custom.count.metric{*}.as_count()")
                .build())
            .thresholds(            
                ServiceLevelObjectiveThresholdArgs.builder()
                    .timeframe("7d")
                    .target(99.9)
                    .warning(99.99)
                    .build(),
                ServiceLevelObjectiveThresholdArgs.builder()
                    .timeframe("30d")
                    .target(99.9)
                    .warning(99.99)
                    .build())
            .timeframe("30d")
            .targetThreshold(99.9)
            .warningThreshold(99.99)
            .tags(            
                "foo:bar",
                "baz")
            .build());

        // Monitor-Based SLO
        // Create a new Datadog service level objective
        var bar = new ServiceLevelObjective("bar", ServiceLevelObjectiveArgs.builder()
            .name("Example Monitor SLO")
            .type("monitor")
            .description("My custom monitor SLO")
            .monitorIds(            
                1,
                2,
                3)
            .thresholds(            
                ServiceLevelObjectiveThresholdArgs.builder()
                    .timeframe("7d")
                    .target(99.9)
                    .warning(99.99)
                    .build(),
                ServiceLevelObjectiveThresholdArgs.builder()
                    .timeframe("30d")
                    .target(99.9)
                    .warning(99.99)
                    .build())
            .timeframe("30d")
            .targetThreshold(99.9)
            .warningThreshold(99.99)
            .tags(            
                "foo:bar",
                "baz")
            .build());

        var timeSliceSlo = new ServiceLevelObjective("timeSliceSlo", ServiceLevelObjectiveArgs.builder()
            .name("Example Time Slice SLO")
            .type("time_slice")
            .description("My custom time slice SLO")
            .sliSpecification(ServiceLevelObjectiveSliSpecificationArgs.builder()
                .timeSlice(ServiceLevelObjectiveSliSpecificationTimeSliceArgs.builder()
                    .query(ServiceLevelObjectiveSliSpecificationTimeSliceQueryArgs.builder()
                        .formula(ServiceLevelObjectiveSliSpecificationTimeSliceQueryFormulaArgs.builder()
                            .formulaExpression("query1")
                            .build())
                        .queries(ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArgs.builder()
                            .metricQuery(ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryMetricQueryArgs.builder()
                                .name("query1")
                                .query("avg:my.custom.count.metric{*}.as_count()")
                                .build())
                            .build())
                        .build())
                    .comparator(">")
                    .threshold(0.9)
                    .build())
                .build())
            .thresholds(ServiceLevelObjectiveThresholdArgs.builder()
                .timeframe("7d")
                .target(99.9)
                .warning(99.99)
                .build())
            .timeframe("7d")
            .targetThreshold(99.9)
            .warningThreshold(99.99)
            .tags(            
                "service:myservice",
                "team:myteam")
            .build());

    }
}

resources:
  # Metric-Based SLO
  # Create a new Datadog service level objective
  foo:
    type: datadog:ServiceLevelObjective
    properties:
      name: Example Metric SLO
      type: metric
      description: My custom metric SLO
      query:
        numerator: sum:my.custom.count.metric{type:good_events}.as_count()
        denominator: sum:my.custom.count.metric{*}.as_count()
      thresholds:
        - timeframe: 7d
          target: 99.9
          warning: 99.99
        - timeframe: 30d
          target: 99.9
          warning: 99.99
      timeframe: 30d
      targetThreshold: 99.9
      warningThreshold: 99.99
      tags:
        - foo:bar
        - baz
  # Monitor-Based SLO
  # Create a new Datadog service level objective
  bar:
    type: datadog:ServiceLevelObjective
    properties:
      name: Example Monitor SLO
      type: monitor
      description: My custom monitor SLO
      monitorIds:
        - 1
        - 2
        - 3
      thresholds:
        - timeframe: 7d
          target: 99.9
          warning: 99.99
        - timeframe: 30d
          target: 99.9
          warning: 99.99
      timeframe: 30d
      targetThreshold: 99.9
      warningThreshold: 99.99
      tags:
        - foo:bar
        - baz
  timeSliceSlo:
    type: datadog:ServiceLevelObjective
    name: time_slice_slo
    properties:
      name: Example Time Slice SLO
      type: time_slice
      description: My custom time slice SLO
      sliSpecification:
        timeSlice:
          query:
            formula:
              formulaExpression: query1
            queries:
              - metricQuery:
                  name: query1
                  query: avg:my.custom.count.metric{*}.as_count()
          comparator: '>'
          threshold: 0.9
      thresholds:
        - timeframe: 7d
          target: 99.9
          warning: 99.99
      timeframe: 7d
      targetThreshold: 99.9
      warningThreshold: 99.99
      tags:
        - service:myservice
        - team:myteam

var serviceLevelObjectiveResource = new Datadog.ServiceLevelObjective("serviceLevelObjectiveResource", new()
{
    Name = "string",
    Type = "string",
    Thresholds = new[]
    {
        new Datadog.Inputs.ServiceLevelObjectiveThresholdArgs
        {
            Target = 0,
            Timeframe = "string",
            TargetDisplay = "string",
            Warning = 0,
            WarningDisplay = "string",
        },
    },
    MonitorIds = new[]
    {
        0,
    },
    Description = "string",
    Query = new Datadog.Inputs.ServiceLevelObjectiveQueryArgs
    {
        Denominator = "string",
        Numerator = "string",
    },
    SliSpecification = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationArgs
    {
        TimeSlice = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceArgs
        {
            Comparator = "string",
            Query = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryArgs
            {
                Formula = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryFormulaArgs
                {
                    FormulaExpression = "string",
                },
                Queries = new[]
                {
                    new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArgs
                    {
                        MetricQuery = new Datadog.Inputs.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryMetricQueryArgs
                        {
                            Name = "string",
                            Query = "string",
                            DataSource = "string",
                        },
                    },
                },
            },
            Threshold = 0,
            QueryIntervalSeconds = 0,
        },
    },
    Tags = new[]
    {
        "string",
    },
    TargetThreshold = 0,
    Groups = new[]
    {
        "string",
    },
    Timeframe = "string",
    ForceDelete = false,
    Validate = false,
    WarningThreshold = 0,
});

example, err := datadog.NewServiceLevelObjective(ctx, "serviceLevelObjectiveResource", &datadog.ServiceLevelObjectiveArgs{
	Name: pulumi.String("string"),
	Type: pulumi.String("string"),
	Thresholds: datadog.ServiceLevelObjectiveThresholdArray{
		&datadog.ServiceLevelObjectiveThresholdArgs{
			Target:         pulumi.Float64(0),
			Timeframe:      pulumi.String("string"),
			TargetDisplay:  pulumi.String("string"),
			Warning:        pulumi.Float64(0),
			WarningDisplay: pulumi.String("string"),
		},
	},
	MonitorIds: pulumi.IntArray{
		pulumi.Int(0),
	},
	Description: pulumi.String("string"),
	Query: &datadog.ServiceLevelObjectiveQueryArgs{
		Denominator: pulumi.String("string"),
		Numerator:   pulumi.String("string"),
	},
	SliSpecification: &datadog.ServiceLevelObjectiveSliSpecificationArgs{
		TimeSlice: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceArgs{
			Comparator: pulumi.String("string"),
			Query: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryArgs{
				Formula: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryFormulaArgs{
					FormulaExpression: pulumi.String("string"),
				},
				Queries: datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArray{
					&datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArgs{
						MetricQuery: &datadog.ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryMetricQueryArgs{
							Name:       pulumi.String("string"),
							Query:      pulumi.String("string"),
							DataSource: pulumi.String("string"),
						},
					},
				},
			},
			Threshold:            pulumi.Float64(0),
			QueryIntervalSeconds: pulumi.Int(0),
		},
	},
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	TargetThreshold: pulumi.Float64(0),
	Groups: pulumi.StringArray{
		pulumi.String("string"),
	},
	Timeframe:        pulumi.String("string"),
	ForceDelete:      pulumi.Bool(false),
	Validate:         pulumi.Bool(false),
	WarningThreshold: pulumi.Float64(0),
})

var serviceLevelObjectiveResource = new ServiceLevelObjective("serviceLevelObjectiveResource", ServiceLevelObjectiveArgs.builder()
    .name("string")
    .type("string")
    .thresholds(ServiceLevelObjectiveThresholdArgs.builder()
        .target(0)
        .timeframe("string")
        .targetDisplay("string")
        .warning(0)
        .warningDisplay("string")
        .build())
    .monitorIds(0)
    .description("string")
    .query(ServiceLevelObjectiveQueryArgs.builder()
        .denominator("string")
        .numerator("string")
        .build())
    .sliSpecification(ServiceLevelObjectiveSliSpecificationArgs.builder()
        .timeSlice(ServiceLevelObjectiveSliSpecificationTimeSliceArgs.builder()
            .comparator("string")
            .query(ServiceLevelObjectiveSliSpecificationTimeSliceQueryArgs.builder()
                .formula(ServiceLevelObjectiveSliSpecificationTimeSliceQueryFormulaArgs.builder()
                    .formulaExpression("string")
                    .build())
                .queries(ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryArgs.builder()
                    .metricQuery(ServiceLevelObjectiveSliSpecificationTimeSliceQueryQueryMetricQueryArgs.builder()
                        .name("string")
                        .query("string")
                        .dataSource("string")
                        .build())
                    .build())
                .build())
            .threshold(0)
            .queryIntervalSeconds(0)
            .build())
        .build())
    .tags("string")
    .targetThreshold(0)
    .groups("string")
    .timeframe("string")
    .forceDelete(false)
    .validate(false)
    .warningThreshold(0)
    .build());

service_level_objective_resource = datadog.ServiceLevelObjective("serviceLevelObjectiveResource",
    name="string",
    type="string",
    thresholds=[{
        "target": 0,
        "timeframe": "string",
        "target_display": "string",
        "warning": 0,
        "warning_display": "string",
    }],
    monitor_ids=[0],
    description="string",
    query={
        "denominator": "string",
        "numerator": "string",
    },
    sli_specification={
        "time_slice": {
            "comparator": "string",
            "query": {
                "formula": {
                    "formula_expression": "string",
                },
                "queries": [{
                    "metric_query": {
                        "name": "string",
                        "query": "string",
                        "data_source": "string",
                    },
                }],
            },
            "threshold": 0,
            "query_interval_seconds": 0,
        },
    },
    tags=["string"],
    target_threshold=0,
    groups=["string"],
    timeframe="string",
    force_delete=False,
    validate=False,
    warning_threshold=0)

const serviceLevelObjectiveResource = new datadog.ServiceLevelObjective("serviceLevelObjectiveResource", {
    name: "string",
    type: "string",
    thresholds: [{
        target: 0,
        timeframe: "string",
        targetDisplay: "string",
        warning: 0,
        warningDisplay: "string",
    }],
    monitorIds: [0],
    description: "string",
    query: {
        denominator: "string",
        numerator: "string",
    },
    sliSpecification: {
        timeSlice: {
            comparator: "string",
            query: {
                formula: {
                    formulaExpression: "string",
                },
                queries: [{
                    metricQuery: {
                        name: "string",
                        query: "string",
                        dataSource: "string",
                    },
                }],
            },
            threshold: 0,
            queryIntervalSeconds: 0,
        },
    },
    tags: ["string"],
    targetThreshold: 0,
    groups: ["string"],
    timeframe: "string",
    forceDelete: false,
    validate: false,
    warningThreshold: 0,
});

type: datadog:ServiceLevelObjective
properties:
    description: string
    forceDelete: false
    groups:
        - string
    monitorIds:
        - 0
    name: string
    query:
        denominator: string
        numerator: string
    sliSpecification:
        timeSlice:
            comparator: string
            query:
                formula:
                    formulaExpression: string
                queries:
                    - metricQuery:
                        dataSource: string
                        name: string
                        query: string
            queryIntervalSeconds: 0
            threshold: 0
    tags:
        - string
    targetThreshold: 0
    thresholds:
        - target: 0
          targetDisplay: string
          timeframe: string
          warning: 0
          warningDisplay: string
    timeframe: string
    type: string
    validate: false
    warningThreshold: 0