sumologic.Slo

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

const sloTfWindowMetricRatio = new sumologic.Slo("slo_tf_window_metric_ratio", {
    name: "login error rate",
    description: "per minute login error rate over rolling 7 days",
    parentId: "0000000000000001",
    signalType: "Error",
    service: "auth",
    application: "login",
    tags: {
        team: "metrics",
        application: "sumologic",
    },
    compliances: [{
        complianceType: "Rolling",
        size: "7d",
        target: 95,
        timezone: "Asia/Kolkata",
    }],
    indicator: {
        windowBasedEvaluation: {
            op: "LessThan",
            queryType: "Metrics",
            size: "1m",
            threshold: 99,
            queries: [
                {
                    queryGroupType: "Unsuccessful",
                    queryGroups: [{
                        rowId: "A",
                        query: "service=auth api=login metric=HTTP_5XX_Count",
                        useRowCount: false,
                    }],
                },
                {
                    queryGroupType: "Total",
                    queryGroups: [{
                        rowId: "A",
                        query: "service=auth api=login metric=TotalRequests",
                        useRowCount: false,
                    }],
                },
            ],
        },
    },
});
const sloTfWindowBased = new sumologic.Slo("slo_tf_window_based", {
    name: "slo-tf-window-based",
    description: "example SLO created with terraform",
    parentId: "0000000000000001",
    signalType: "Latency",
    service: "auth",
    application: "login",
    tags: {
        team: "metrics",
        application: "sumologic",
    },
    compliances: [{
        complianceType: "Rolling",
        size: "7d",
        target: 99,
        timezone: "Asia/Kolkata",
    }],
    indicator: {
        windowBasedEvaluation: {
            op: "LessThan",
            queryType: "Metrics",
            aggregation: "Avg",
            size: "1m",
            threshold: 200,
            queries: [{
                queryGroupType: "Threshold",
                queryGroups: [{
                    rowId: "A",
                    query: "metric=request_time_p90  service=auth api=login",
                    useRowCount: false,
                }],
            }],
        },
    },
});
const sloTfRequestBased = new sumologic.Slo("slo_tf_request_based", {
    name: "slo-tf-request-based",
    description: "example SLO created with terraform for request based SLI",
    parentId: tfSloFolder.id,
    signalType: "Latency",
    service: "auth",
    application: "login",
    tags: {
        team: "metrics",
        application: "sumologic",
    },
    compliances: [{
        complianceType: "Rolling",
        size: "7d",
        target: 99,
        timezone: "Asia/Kolkata",
    }],
    indicator: {
        requestBasedEvaluation: {
            op: "LessThanOrEqual",
            queryType: "Logs",
            threshold: 1,
            queries: [{
                queryGroupType: "Threshold",
                queryGroups: [{
                    rowId: "A",
                    query: `          cluster=sedemostaging namespace=warp004*
              | parse "Coffee preparation request time: * ms" as latency nodrop
              |  if(isBlank(latency), "false", "true") as hasLatency
              | where hasLatency = "true"
              |  if(isBlank(latency), 0.0, latency) as latency
              | latency/ 1000 as latency_sec
`,
                    useRowCount: false,
                    field: "latency_sec",
                }],
            }],
        },
    },
});
const sloTfMonitorBased = new sumologic.Slo("slo_tf_monitor_based", {
    name: "slo-tf-monitor-based",
    description: "example of monitor based SLO created with terraform",
    parentId: "0000000000000001",
    signalType: "Error",
    service: "auth",
    application: "login",
    tags: {
        team: "metrics",
        application: "sumologic",
    },
    compliances: [{
        complianceType: "Rolling",
        size: "7d",
        target: 99,
        timezone: "Asia/Kolkata",
    }],
    indicator: {
        monitorBasedEvaluation: {
            monitorTriggers: {
                monitorId: "0000000000BCB3A4",
                triggerTypes: "Critical",
            },
        },
    },
});

import pulumi
import pulumi_sumologic as sumologic

slo_tf_window_metric_ratio = sumologic.Slo("slo_tf_window_metric_ratio",
    name="login error rate",
    description="per minute login error rate over rolling 7 days",
    parent_id="0000000000000001",
    signal_type="Error",
    service="auth",
    application="login",
    tags={
        "team": "metrics",
        "application": "sumologic",
    },
    compliances=[{
        "compliance_type": "Rolling",
        "size": "7d",
        "target": 95,
        "timezone": "Asia/Kolkata",
    }],
    indicator={
        "window_based_evaluation": {
            "op": "LessThan",
            "query_type": "Metrics",
            "size": "1m",
            "threshold": 99,
            "queries": [
                {
                    "query_group_type": "Unsuccessful",
                    "query_groups": [{
                        "row_id": "A",
                        "query": "service=auth api=login metric=HTTP_5XX_Count",
                        "use_row_count": False,
                    }],
                },
                {
                    "query_group_type": "Total",
                    "query_groups": [{
                        "row_id": "A",
                        "query": "service=auth api=login metric=TotalRequests",
                        "use_row_count": False,
                    }],
                },
            ],
        },
    })
slo_tf_window_based = sumologic.Slo("slo_tf_window_based",
    name="slo-tf-window-based",
    description="example SLO created with terraform",
    parent_id="0000000000000001",
    signal_type="Latency",
    service="auth",
    application="login",
    tags={
        "team": "metrics",
        "application": "sumologic",
    },
    compliances=[{
        "compliance_type": "Rolling",
        "size": "7d",
        "target": 99,
        "timezone": "Asia/Kolkata",
    }],
    indicator={
        "window_based_evaluation": {
            "op": "LessThan",
            "query_type": "Metrics",
            "aggregation": "Avg",
            "size": "1m",
            "threshold": 200,
            "queries": [{
                "query_group_type": "Threshold",
                "query_groups": [{
                    "row_id": "A",
                    "query": "metric=request_time_p90  service=auth api=login",
                    "use_row_count": False,
                }],
            }],
        },
    })
slo_tf_request_based = sumologic.Slo("slo_tf_request_based",
    name="slo-tf-request-based",
    description="example SLO created with terraform for request based SLI",
    parent_id=tf_slo_folder["id"],
    signal_type="Latency",
    service="auth",
    application="login",
    tags={
        "team": "metrics",
        "application": "sumologic",
    },
    compliances=[{
        "compliance_type": "Rolling",
        "size": "7d",
        "target": 99,
        "timezone": "Asia/Kolkata",
    }],
    indicator={
        "request_based_evaluation": {
            "op": "LessThanOrEqual",
            "query_type": "Logs",
            "threshold": 1,
            "queries": [{
                "query_group_type": "Threshold",
                "query_groups": [{
                    "row_id": "A",
                    "query": """          cluster=sedemostaging namespace=warp004*
              | parse "Coffee preparation request time: * ms" as latency nodrop
              |  if(isBlank(latency), "false", "true") as hasLatency
              | where hasLatency = "true"
              |  if(isBlank(latency), 0.0, latency) as latency
              | latency/ 1000 as latency_sec
""",
                    "use_row_count": False,
                    "field": "latency_sec",
                }],
            }],
        },
    })
slo_tf_monitor_based = sumologic.Slo("slo_tf_monitor_based",
    name="slo-tf-monitor-based",
    description="example of monitor based SLO created with terraform",
    parent_id="0000000000000001",
    signal_type="Error",
    service="auth",
    application="login",
    tags={
        "team": "metrics",
        "application": "sumologic",
    },
    compliances=[{
        "compliance_type": "Rolling",
        "size": "7d",
        "target": 99,
        "timezone": "Asia/Kolkata",
    }],
    indicator={
        "monitor_based_evaluation": {
            "monitor_triggers": {
                "monitor_id": "0000000000BCB3A4",
                "trigger_types": "Critical",
            },
        },
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sumologic.NewSlo(ctx, "slo_tf_window_metric_ratio", &sumologic.SloArgs{
			Name:        pulumi.String("login error rate"),
			Description: pulumi.String("per minute login error rate over rolling 7 days"),
			ParentId:    pulumi.String("0000000000000001"),
			SignalType:  pulumi.String("Error"),
			Service:     pulumi.String("auth"),
			Application: pulumi.String("login"),
			Tags: pulumi.StringMap{
				"team":        pulumi.String("metrics"),
				"application": pulumi.String("sumologic"),
			},
			Compliances: sumologic.SloComplianceArray{
				&sumologic.SloComplianceArgs{
					ComplianceType: pulumi.String("Rolling"),
					Size:           pulumi.String("7d"),
					Target:         pulumi.Float64(95),
					Timezone:       pulumi.String("Asia/Kolkata"),
				},
			},
			Indicator: &sumologic.SloIndicatorArgs{
				WindowBasedEvaluation: &sumologic.SloIndicatorWindowBasedEvaluationArgs{
					Op:        pulumi.String("LessThan"),
					QueryType: pulumi.String("Metrics"),
					Size:      pulumi.String("1m"),
					Threshold: pulumi.Float64(99),
					Queries: sumologic.SloIndicatorWindowBasedEvaluationQueryArray{
						&sumologic.SloIndicatorWindowBasedEvaluationQueryArgs{
							QueryGroupType: pulumi.String("Unsuccessful"),
							QueryGroups: sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArray{
								&sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs{
									RowId:       pulumi.String("A"),
									Query:       pulumi.String("service=auth api=login metric=HTTP_5XX_Count"),
									UseRowCount: pulumi.Bool(false),
								},
							},
						},
						&sumologic.SloIndicatorWindowBasedEvaluationQueryArgs{
							QueryGroupType: pulumi.String("Total"),
							QueryGroups: sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArray{
								&sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs{
									RowId:       pulumi.String("A"),
									Query:       pulumi.String("service=auth api=login metric=TotalRequests"),
									UseRowCount: pulumi.Bool(false),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = sumologic.NewSlo(ctx, "slo_tf_window_based", &sumologic.SloArgs{
			Name:        pulumi.String("slo-tf-window-based"),
			Description: pulumi.String("example SLO created with terraform"),
			ParentId:    pulumi.String("0000000000000001"),
			SignalType:  pulumi.String("Latency"),
			Service:     pulumi.String("auth"),
			Application: pulumi.String("login"),
			Tags: pulumi.StringMap{
				"team":        pulumi.String("metrics"),
				"application": pulumi.String("sumologic"),
			},
			Compliances: sumologic.SloComplianceArray{
				&sumologic.SloComplianceArgs{
					ComplianceType: pulumi.String("Rolling"),
					Size:           pulumi.String("7d"),
					Target:         pulumi.Float64(99),
					Timezone:       pulumi.String("Asia/Kolkata"),
				},
			},
			Indicator: &sumologic.SloIndicatorArgs{
				WindowBasedEvaluation: &sumologic.SloIndicatorWindowBasedEvaluationArgs{
					Op:          pulumi.String("LessThan"),
					QueryType:   pulumi.String("Metrics"),
					Aggregation: pulumi.String("Avg"),
					Size:        pulumi.String("1m"),
					Threshold:   pulumi.Float64(200),
					Queries: sumologic.SloIndicatorWindowBasedEvaluationQueryArray{
						&sumologic.SloIndicatorWindowBasedEvaluationQueryArgs{
							QueryGroupType: pulumi.String("Threshold"),
							QueryGroups: sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArray{
								&sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs{
									RowId:       pulumi.String("A"),
									Query:       pulumi.String("metric=request_time_p90  service=auth api=login"),
									UseRowCount: pulumi.Bool(false),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = sumologic.NewSlo(ctx, "slo_tf_request_based", &sumologic.SloArgs{
			Name:        pulumi.String("slo-tf-request-based"),
			Description: pulumi.String("example SLO created with terraform for request based SLI"),
			ParentId:    pulumi.Any(tfSloFolder.Id),
			SignalType:  pulumi.String("Latency"),
			Service:     pulumi.String("auth"),
			Application: pulumi.String("login"),
			Tags: pulumi.StringMap{
				"team":        pulumi.String("metrics"),
				"application": pulumi.String("sumologic"),
			},
			Compliances: sumologic.SloComplianceArray{
				&sumologic.SloComplianceArgs{
					ComplianceType: pulumi.String("Rolling"),
					Size:           pulumi.String("7d"),
					Target:         pulumi.Float64(99),
					Timezone:       pulumi.String("Asia/Kolkata"),
				},
			},
			Indicator: &sumologic.SloIndicatorArgs{
				RequestBasedEvaluation: &sumologic.SloIndicatorRequestBasedEvaluationArgs{
					Op:        pulumi.String("LessThanOrEqual"),
					QueryType: pulumi.String("Logs"),
					Threshold: pulumi.Float64(1),
					Queries: sumologic.SloIndicatorRequestBasedEvaluationQueryArray{
						&sumologic.SloIndicatorRequestBasedEvaluationQueryArgs{
							QueryGroupType: pulumi.String("Threshold"),
							QueryGroups: sumologic.SloIndicatorRequestBasedEvaluationQueryQueryGroupArray{
								&sumologic.SloIndicatorRequestBasedEvaluationQueryQueryGroupArgs{
									RowId: pulumi.String("A"),
									Query: pulumi.String(`          cluster=sedemostaging namespace=warp004*
              | parse "Coffee preparation request time: * ms" as latency nodrop
              |  if(isBlank(latency), "false", "true") as hasLatency
              | where hasLatency = "true"
              |  if(isBlank(latency), 0.0, latency) as latency
              | latency/ 1000 as latency_sec
`),
									UseRowCount: pulumi.Bool(false),
									Field:       pulumi.String("latency_sec"),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = sumologic.NewSlo(ctx, "slo_tf_monitor_based", &sumologic.SloArgs{
			Name:        pulumi.String("slo-tf-monitor-based"),
			Description: pulumi.String("example of monitor based SLO created with terraform"),
			ParentId:    pulumi.String("0000000000000001"),
			SignalType:  pulumi.String("Error"),
			Service:     pulumi.String("auth"),
			Application: pulumi.String("login"),
			Tags: pulumi.StringMap{
				"team":        pulumi.String("metrics"),
				"application": pulumi.String("sumologic"),
			},
			Compliances: sumologic.SloComplianceArray{
				&sumologic.SloComplianceArgs{
					ComplianceType: pulumi.String("Rolling"),
					Size:           pulumi.String("7d"),
					Target:         pulumi.Float64(99),
					Timezone:       pulumi.String("Asia/Kolkata"),
				},
			},
			Indicator: &sumologic.SloIndicatorArgs{
				MonitorBasedEvaluation: &sumologic.SloIndicatorMonitorBasedEvaluationArgs{
					MonitorTriggers: &sumologic.SloIndicatorMonitorBasedEvaluationMonitorTriggersArgs{
						MonitorId:    pulumi.String("0000000000BCB3A4"),
						TriggerTypes: pulumi.String("Critical"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var sloTfWindowMetricRatio = new SumoLogic.Slo("slo_tf_window_metric_ratio", new()
    {
        Name = "login error rate",
        Description = "per minute login error rate over rolling 7 days",
        ParentId = "0000000000000001",
        SignalType = "Error",
        Service = "auth",
        Application = "login",
        Tags = 
        {
            { "team", "metrics" },
            { "application", "sumologic" },
        },
        Compliances = new[]
        {
            new SumoLogic.Inputs.SloComplianceArgs
            {
                ComplianceType = "Rolling",
                Size = "7d",
                Target = 95,
                Timezone = "Asia/Kolkata",
            },
        },
        Indicator = new SumoLogic.Inputs.SloIndicatorArgs
        {
            WindowBasedEvaluation = new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationArgs
            {
                Op = "LessThan",
                QueryType = "Metrics",
                Size = "1m",
                Threshold = 99,
                Queries = new[]
                {
                    new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryArgs
                    {
                        QueryGroupType = "Unsuccessful",
                        QueryGroups = new[]
                        {
                            new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs
                            {
                                RowId = "A",
                                Query = "service=auth api=login metric=HTTP_5XX_Count",
                                UseRowCount = false,
                            },
                        },
                    },
                    new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryArgs
                    {
                        QueryGroupType = "Total",
                        QueryGroups = new[]
                        {
                            new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs
                            {
                                RowId = "A",
                                Query = "service=auth api=login metric=TotalRequests",
                                UseRowCount = false,
                            },
                        },
                    },
                },
            },
        },
    });

    var sloTfWindowBased = new SumoLogic.Slo("slo_tf_window_based", new()
    {
        Name = "slo-tf-window-based",
        Description = "example SLO created with terraform",
        ParentId = "0000000000000001",
        SignalType = "Latency",
        Service = "auth",
        Application = "login",
        Tags = 
        {
            { "team", "metrics" },
            { "application", "sumologic" },
        },
        Compliances = new[]
        {
            new SumoLogic.Inputs.SloComplianceArgs
            {
                ComplianceType = "Rolling",
                Size = "7d",
                Target = 99,
                Timezone = "Asia/Kolkata",
            },
        },
        Indicator = new SumoLogic.Inputs.SloIndicatorArgs
        {
            WindowBasedEvaluation = new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationArgs
            {
                Op = "LessThan",
                QueryType = "Metrics",
                Aggregation = "Avg",
                Size = "1m",
                Threshold = 200,
                Queries = new[]
                {
                    new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryArgs
                    {
                        QueryGroupType = "Threshold",
                        QueryGroups = new[]
                        {
                            new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs
                            {
                                RowId = "A",
                                Query = "metric=request_time_p90  service=auth api=login",
                                UseRowCount = false,
                            },
                        },
                    },
                },
            },
        },
    });

    var sloTfRequestBased = new SumoLogic.Slo("slo_tf_request_based", new()
    {
        Name = "slo-tf-request-based",
        Description = "example SLO created with terraform for request based SLI",
        ParentId = tfSloFolder.Id,
        SignalType = "Latency",
        Service = "auth",
        Application = "login",
        Tags = 
        {
            { "team", "metrics" },
            { "application", "sumologic" },
        },
        Compliances = new[]
        {
            new SumoLogic.Inputs.SloComplianceArgs
            {
                ComplianceType = "Rolling",
                Size = "7d",
                Target = 99,
                Timezone = "Asia/Kolkata",
            },
        },
        Indicator = new SumoLogic.Inputs.SloIndicatorArgs
        {
            RequestBasedEvaluation = new SumoLogic.Inputs.SloIndicatorRequestBasedEvaluationArgs
            {
                Op = "LessThanOrEqual",
                QueryType = "Logs",
                Threshold = 1,
                Queries = new[]
                {
                    new SumoLogic.Inputs.SloIndicatorRequestBasedEvaluationQueryArgs
                    {
                        QueryGroupType = "Threshold",
                        QueryGroups = new[]
                        {
                            new SumoLogic.Inputs.SloIndicatorRequestBasedEvaluationQueryQueryGroupArgs
                            {
                                RowId = "A",
                                Query = @"          cluster=sedemostaging namespace=warp004*
              | parse ""Coffee preparation request time: * ms"" as latency nodrop
              |  if(isBlank(latency), ""false"", ""true"") as hasLatency
              | where hasLatency = ""true""
              |  if(isBlank(latency), 0.0, latency) as latency
              | latency/ 1000 as latency_sec
",
                                UseRowCount = false,
                                Field = "latency_sec",
                            },
                        },
                    },
                },
            },
        },
    });

    var sloTfMonitorBased = new SumoLogic.Slo("slo_tf_monitor_based", new()
    {
        Name = "slo-tf-monitor-based",
        Description = "example of monitor based SLO created with terraform",
        ParentId = "0000000000000001",
        SignalType = "Error",
        Service = "auth",
        Application = "login",
        Tags = 
        {
            { "team", "metrics" },
            { "application", "sumologic" },
        },
        Compliances = new[]
        {
            new SumoLogic.Inputs.SloComplianceArgs
            {
                ComplianceType = "Rolling",
                Size = "7d",
                Target = 99,
                Timezone = "Asia/Kolkata",
            },
        },
        Indicator = new SumoLogic.Inputs.SloIndicatorArgs
        {
            MonitorBasedEvaluation = new SumoLogic.Inputs.SloIndicatorMonitorBasedEvaluationArgs
            {
                MonitorTriggers = new SumoLogic.Inputs.SloIndicatorMonitorBasedEvaluationMonitorTriggersArgs
                {
                    MonitorId = "0000000000BCB3A4",
                    TriggerTypes = "Critical",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.sumologic.Slo;
import com.pulumi.sumologic.SloArgs;
import com.pulumi.sumologic.inputs.SloComplianceArgs;
import com.pulumi.sumologic.inputs.SloIndicatorArgs;
import com.pulumi.sumologic.inputs.SloIndicatorWindowBasedEvaluationArgs;
import com.pulumi.sumologic.inputs.SloIndicatorRequestBasedEvaluationArgs;
import com.pulumi.sumologic.inputs.SloIndicatorMonitorBasedEvaluationArgs;
import com.pulumi.sumologic.inputs.SloIndicatorMonitorBasedEvaluationMonitorTriggersArgs;
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 sloTfWindowMetricRatio = new Slo("sloTfWindowMetricRatio", SloArgs.builder()
            .name("login error rate")
            .description("per minute login error rate over rolling 7 days")
            .parentId("0000000000000001")
            .signalType("Error")
            .service("auth")
            .application("login")
            .tags(Map.ofEntries(
                Map.entry("team", "metrics"),
                Map.entry("application", "sumologic")
            ))
            .compliances(SloComplianceArgs.builder()
                .complianceType("Rolling")
                .size("7d")
                .target(95)
                .timezone("Asia/Kolkata")
                .build())
            .indicator(SloIndicatorArgs.builder()
                .windowBasedEvaluation(SloIndicatorWindowBasedEvaluationArgs.builder()
                    .op("LessThan")
                    .queryType("Metrics")
                    .size("1m")
                    .threshold(99)
                    .queries(                    
                        SloIndicatorWindowBasedEvaluationQueryArgs.builder()
                            .queryGroupType("Unsuccessful")
                            .queryGroups(SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs.builder()
                                .rowId("A")
                                .query("service=auth api=login metric=HTTP_5XX_Count")
                                .useRowCount(false)
                                .build())
                            .build(),
                        SloIndicatorWindowBasedEvaluationQueryArgs.builder()
                            .queryGroupType("Total")
                            .queryGroups(SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs.builder()
                                .rowId("A")
                                .query("service=auth api=login metric=TotalRequests")
                                .useRowCount(false)
                                .build())
                            .build())
                    .build())
                .build())
            .build());

        var sloTfWindowBased = new Slo("sloTfWindowBased", SloArgs.builder()
            .name("slo-tf-window-based")
            .description("example SLO created with terraform")
            .parentId("0000000000000001")
            .signalType("Latency")
            .service("auth")
            .application("login")
            .tags(Map.ofEntries(
                Map.entry("team", "metrics"),
                Map.entry("application", "sumologic")
            ))
            .compliances(SloComplianceArgs.builder()
                .complianceType("Rolling")
                .size("7d")
                .target(99)
                .timezone("Asia/Kolkata")
                .build())
            .indicator(SloIndicatorArgs.builder()
                .windowBasedEvaluation(SloIndicatorWindowBasedEvaluationArgs.builder()
                    .op("LessThan")
                    .queryType("Metrics")
                    .aggregation("Avg")
                    .size("1m")
                    .threshold(200)
                    .queries(SloIndicatorWindowBasedEvaluationQueryArgs.builder()
                        .queryGroupType("Threshold")
                        .queryGroups(SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs.builder()
                            .rowId("A")
                            .query("metric=request_time_p90  service=auth api=login")
                            .useRowCount(false)
                            .build())
                        .build())
                    .build())
                .build())
            .build());

        var sloTfRequestBased = new Slo("sloTfRequestBased", SloArgs.builder()
            .name("slo-tf-request-based")
            .description("example SLO created with terraform for request based SLI")
            .parentId(tfSloFolder.id())
            .signalType("Latency")
            .service("auth")
            .application("login")
            .tags(Map.ofEntries(
                Map.entry("team", "metrics"),
                Map.entry("application", "sumologic")
            ))
            .compliances(SloComplianceArgs.builder()
                .complianceType("Rolling")
                .size("7d")
                .target(99)
                .timezone("Asia/Kolkata")
                .build())
            .indicator(SloIndicatorArgs.builder()
                .requestBasedEvaluation(SloIndicatorRequestBasedEvaluationArgs.builder()
                    .op("LessThanOrEqual")
                    .queryType("Logs")
                    .threshold(1)
                    .queries(SloIndicatorRequestBasedEvaluationQueryArgs.builder()
                        .queryGroupType("Threshold")
                        .queryGroups(SloIndicatorRequestBasedEvaluationQueryQueryGroupArgs.builder()
                            .rowId("A")
                            .query("""
          cluster=sedemostaging namespace=warp004*
              | parse "Coffee preparation request time: * ms" as latency nodrop
              |  if(isBlank(latency), "false", "true") as hasLatency
              | where hasLatency = "true"
              |  if(isBlank(latency), 0.0, latency) as latency
              | latency/ 1000 as latency_sec
                            """)
                            .useRowCount(false)
                            .field("latency_sec")
                            .build())
                        .build())
                    .build())
                .build())
            .build());

        var sloTfMonitorBased = new Slo("sloTfMonitorBased", SloArgs.builder()
            .name("slo-tf-monitor-based")
            .description("example of monitor based SLO created with terraform")
            .parentId("0000000000000001")
            .signalType("Error")
            .service("auth")
            .application("login")
            .tags(Map.ofEntries(
                Map.entry("team", "metrics"),
                Map.entry("application", "sumologic")
            ))
            .compliances(SloComplianceArgs.builder()
                .complianceType("Rolling")
                .size("7d")
                .target(99)
                .timezone("Asia/Kolkata")
                .build())
            .indicator(SloIndicatorArgs.builder()
                .monitorBasedEvaluation(SloIndicatorMonitorBasedEvaluationArgs.builder()
                    .monitorTriggers(SloIndicatorMonitorBasedEvaluationMonitorTriggersArgs.builder()
                        .monitorId("0000000000BCB3A4")
                        .triggerTypes("Critical")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  sloTfWindowMetricRatio:
    type: sumologic:Slo
    name: slo_tf_window_metric_ratio
    properties:
      name: login error rate
      description: per minute login error rate over rolling 7 days
      parentId: '0000000000000001'
      signalType: Error
      service: auth
      application: login
      tags:
        team: metrics
        application: sumologic
      compliances:
        - complianceType: Rolling
          size: 7d
          target: 95
          timezone: Asia/Kolkata
      indicator:
        windowBasedEvaluation:
          op: LessThan
          queryType: Metrics
          size: 1m
          threshold: 99
          queries:
            - queryGroupType: Unsuccessful
              queryGroups:
                - rowId: A
                  query: service=auth api=login metric=HTTP_5XX_Count
                  useRowCount: false
            - queryGroupType: Total
              queryGroups:
                - rowId: A
                  query: service=auth api=login metric=TotalRequests
                  useRowCount: false
  sloTfWindowBased:
    type: sumologic:Slo
    name: slo_tf_window_based
    properties:
      name: slo-tf-window-based
      description: example SLO created with terraform
      parentId: '0000000000000001'
      signalType: Latency
      service: auth
      application: login
      tags:
        team: metrics
        application: sumologic
      compliances:
        - complianceType: Rolling
          size: 7d
          target: 99
          timezone: Asia/Kolkata
      indicator:
        windowBasedEvaluation:
          op: LessThan
          queryType: Metrics
          aggregation: Avg
          size: 1m
          threshold: 200
          queries:
            - queryGroupType: Threshold
              queryGroups:
                - rowId: A
                  query: metric=request_time_p90  service=auth api=login
                  useRowCount: false
  sloTfRequestBased:
    type: sumologic:Slo
    name: slo_tf_request_based
    properties:
      name: slo-tf-request-based
      description: example SLO created with terraform for request based SLI
      parentId: ${tfSloFolder.id}
      signalType: Latency
      service: auth
      application: login
      tags:
        team: metrics
        application: sumologic
      compliances:
        - complianceType: Rolling
          size: 7d
          target: 99
          timezone: Asia/Kolkata
      indicator:
        requestBasedEvaluation:
          op: LessThanOrEqual
          queryType: Logs
          threshold: 1
          queries:
            - queryGroupType: Threshold
              queryGroups:
                - rowId: A
                  query: |2
                              cluster=sedemostaging namespace=warp004*
                                  | parse "Coffee preparation request time: * ms" as latency nodrop
                                  |  if(isBlank(latency), "false", "true") as hasLatency
                                  | where hasLatency = "true"
                                  |  if(isBlank(latency), 0.0, latency) as latency
                                  | latency/ 1000 as latency_sec
                  useRowCount: false
                  field: latency_sec
  sloTfMonitorBased:
    type: sumologic:Slo
    name: slo_tf_monitor_based
    properties:
      name: slo-tf-monitor-based
      description: example of monitor based SLO created with terraform
      parentId: '0000000000000001'
      signalType: Error
      service: auth
      application: login
      tags:
        team: metrics
        application: sumologic
      compliances:
        - complianceType: Rolling
          size: 7d
          target: 99
          timezone: Asia/Kolkata
      indicator:
        monitorBasedEvaluation:
          monitorTriggers:
            monitorId: 0000000000BCB3A4
            triggerTypes: Critical

var sloResource = new SumoLogic.Slo("sloResource", new()
{
    Indicator = new SumoLogic.Inputs.SloIndicatorArgs
    {
        MonitorBasedEvaluation = new SumoLogic.Inputs.SloIndicatorMonitorBasedEvaluationArgs
        {
            MonitorTriggers = new SumoLogic.Inputs.SloIndicatorMonitorBasedEvaluationMonitorTriggersArgs
            {
                MonitorId = "string",
                TriggerTypes = "string",
            },
        },
        RequestBasedEvaluation = new SumoLogic.Inputs.SloIndicatorRequestBasedEvaluationArgs
        {
            Queries = new[]
            {
                new SumoLogic.Inputs.SloIndicatorRequestBasedEvaluationQueryArgs
                {
                    QueryGroupType = "string",
                    QueryGroups = new[]
                    {
                        new SumoLogic.Inputs.SloIndicatorRequestBasedEvaluationQueryQueryGroupArgs
                        {
                            Query = "string",
                            RowId = "string",
                            UseRowCount = false,
                            Field = "string",
                        },
                    },
                },
            },
            QueryType = "string",
            Op = "string",
            Threshold = 0,
        },
        WindowBasedEvaluation = new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationArgs
        {
            Op = "string",
            Queries = new[]
            {
                new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryArgs
                {
                    QueryGroupType = "string",
                    QueryGroups = new[]
                    {
                        new SumoLogic.Inputs.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs
                        {
                            Query = "string",
                            RowId = "string",
                            UseRowCount = false,
                            Field = "string",
                        },
                    },
                },
            },
            QueryType = "string",
            Size = "string",
            Threshold = 0,
            Aggregation = "string",
        },
    },
    Compliances = new[]
    {
        new SumoLogic.Inputs.SloComplianceArgs
        {
            ComplianceType = "string",
            Size = "string",
            Target = 0,
            Timezone = "string",
            StartFrom = "string",
        },
    },
    SignalType = "string",
    IsSystem = false,
    ModifiedBy = "string",
    CreatedBy = "string",
    IsLocked = false,
    IsMutable = false,
    Application = "string",
    ModifiedAt = "string",
    Description = "string",
    Name = "string",
    ParentId = "string",
    PostRequestMap = 
    {
        { "string", "string" },
    },
    Service = "string",
    CreatedAt = "string",
    Tags = 
    {
        { "string", "string" },
    },
    Version = 0,
});

example, err := sumologic.NewSlo(ctx, "sloResource", &sumologic.SloArgs{
	Indicator: &sumologic.SloIndicatorArgs{
		MonitorBasedEvaluation: &sumologic.SloIndicatorMonitorBasedEvaluationArgs{
			MonitorTriggers: &sumologic.SloIndicatorMonitorBasedEvaluationMonitorTriggersArgs{
				MonitorId:    pulumi.String("string"),
				TriggerTypes: pulumi.String("string"),
			},
		},
		RequestBasedEvaluation: &sumologic.SloIndicatorRequestBasedEvaluationArgs{
			Queries: sumologic.SloIndicatorRequestBasedEvaluationQueryArray{
				&sumologic.SloIndicatorRequestBasedEvaluationQueryArgs{
					QueryGroupType: pulumi.String("string"),
					QueryGroups: sumologic.SloIndicatorRequestBasedEvaluationQueryQueryGroupArray{
						&sumologic.SloIndicatorRequestBasedEvaluationQueryQueryGroupArgs{
							Query:       pulumi.String("string"),
							RowId:       pulumi.String("string"),
							UseRowCount: pulumi.Bool(false),
							Field:       pulumi.String("string"),
						},
					},
				},
			},
			QueryType: pulumi.String("string"),
			Op:        pulumi.String("string"),
			Threshold: pulumi.Float64(0),
		},
		WindowBasedEvaluation: &sumologic.SloIndicatorWindowBasedEvaluationArgs{
			Op: pulumi.String("string"),
			Queries: sumologic.SloIndicatorWindowBasedEvaluationQueryArray{
				&sumologic.SloIndicatorWindowBasedEvaluationQueryArgs{
					QueryGroupType: pulumi.String("string"),
					QueryGroups: sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArray{
						&sumologic.SloIndicatorWindowBasedEvaluationQueryQueryGroupArgs{
							Query:       pulumi.String("string"),
							RowId:       pulumi.String("string"),
							UseRowCount: pulumi.Bool(false),
							Field:       pulumi.String("string"),
						},
					},
				},
			},
			QueryType:   pulumi.String("string"),
			Size:        pulumi.String("string"),
			Threshold:   pulumi.Float64(0),
			Aggregation: pulumi.String("string"),
		},
	},
	Compliances: sumologic.SloComplianceArray{
		&sumologic.SloComplianceArgs{
			ComplianceType: pulumi.String("string"),
			Size:           pulumi.String("string"),
			Target:         pulumi.Float64(0),
			Timezone:       pulumi.String("string"),
			StartFrom:      pulumi.String("string"),
		},
	},
	SignalType:  pulumi.String("string"),
	IsSystem:    pulumi.Bool(false),
	ModifiedBy:  pulumi.String("string"),
	CreatedBy:   pulumi.String("string"),
	IsLocked:    pulumi.Bool(false),
	IsMutable:   pulumi.Bool(false),
	Application: pulumi.String("string"),
	ModifiedAt:  pulumi.String("string"),
	Description: pulumi.String("string"),
	Name:        pulumi.String("string"),
	ParentId:    pulumi.String("string"),
	PostRequestMap: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Service:   pulumi.String("string"),
	CreatedAt: pulumi.String("string"),
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Version: pulumi.Int(0),
})