1. Packages
  2. Sumo Logic
  3. API Docs
  4. Monitor
Sumo Logic v0.20.2 published on Friday, Feb 2, 2024 by Pulumi

sumologic.Monitor

Explore with Pulumi AI

sumologic logo
Sumo Logic v0.20.2 published on Friday, Feb 2, 2024 by Pulumi

    Provides the ability to create, read, delete, and update Monitors. If Fine Grain Permission (FGP) feature is enabled with Monitors Content at one’s Sumo Logic account, one can also set those permission details under this monitor resource. For further details about FGP, please see this Monitor Permission document.

    Example SLO Monitors

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.sumologic.Monitor;
    import com.pulumi.sumologic.MonitorArgs;
    import com.pulumi.sumologic.inputs.MonitorNotificationArgs;
    import com.pulumi.sumologic.inputs.MonitorNotificationNotificationArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerConditionsArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerConditionsSloSliConditionArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerConditionsSloSliConditionCriticalArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerConditionsSloSliConditionWarningArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerConditionsSloBurnRateConditionArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerConditionsSloBurnRateConditionCriticalArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerConditionsSloBurnRateConditionWarningArgs;
    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 tfSloMonitor1 = new Monitor("tfSloMonitor1", MonitorArgs.builder()        
                .contentType("Monitor")
                .evaluationDelay("5m")
                .isDisabled(false)
                .monitorType("Slo")
                .notifications(MonitorNotificationArgs.builder()
                    .notification(MonitorNotificationNotificationArgs.builder()
                        .connectionType("Email")
                        .messageBody("Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}")
                        .recipients("abc@example.com")
                        .subject("Monitor Alert: {{TriggerType}} on {{Name}}")
                        .timeZone("PST")
                        .build())
                    .runForTriggerTypes(                
                        "Critical",
                        "ResolvedCritical")
                    .build())
                .playbook("test playbook")
                .sloId("0000000000000009")
                .tags(Map.ofEntries(
                    Map.entry("application", "sumologic"),
                    Map.entry("team", "monitoring")
                ))
                .triggerConditions(MonitorTriggerConditionsArgs.builder()
                    .sloSliCondition(MonitorTriggerConditionsSloSliConditionArgs.builder()
                        .critical(MonitorTriggerConditionsSloSliConditionCriticalArgs.builder()
                            .sliThreshold(99.5)
                            .build())
                        .warning(MonitorTriggerConditionsSloSliConditionWarningArgs.builder()
                            .sliThreshold(99.9)
                            .build())
                        .build())
                    .build())
                .type("MonitorsLibraryMonitor")
                .build());
    
            var tfSloMonitor2 = new Monitor("tfSloMonitor2", MonitorArgs.builder()        
                .contentType("Monitor")
                .evaluationDelay("5m")
                .isDisabled(false)
                .monitorType("Slo")
                .sloId("0000000000000009")
                .tags(Map.ofEntries(
                    Map.entry("application", "sumologic"),
                    Map.entry("team", "monitoring")
                ))
                .triggerConditions(MonitorTriggerConditionsArgs.builder()
                    .sloBurnRateCondition(MonitorTriggerConditionsSloBurnRateConditionArgs.builder()
                        .critical(MonitorTriggerConditionsSloBurnRateConditionCriticalArgs.builder()
                            .burnRate(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .build())
                        .warning(MonitorTriggerConditionsSloBurnRateConditionWarningArgs.builder()
                            .burnRate(                        
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .build())
                        .build())
                    .build())
                .type("MonitorsLibraryMonitor")
                .build());
    
        }
    }
    
    resources:
      tfSloMonitor1:
        type: sumologic:Monitor
        properties:
          contentType: Monitor
          evaluationDelay: 5m
          isDisabled: false
          monitorType: Slo
          notifications:
            - notification:
                connectionType: Email
                messageBody: 'Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}'
                recipients:
                  - abc@example.com
                subject: 'Monitor Alert: {{TriggerType}} on {{Name}}'
                timeZone: PST
              runForTriggerTypes:
                - Critical
                - ResolvedCritical
          playbook: test playbook
          sloId: '0000000000000009'
          tags:
            application: sumologic
            team: monitoring
          triggerConditions:
            sloSliCondition:
              critical:
                sliThreshold: 99.5
              warning:
                sliThreshold: 99.9
          type: MonitorsLibraryMonitor
      tfSloMonitor2:
        type: sumologic:Monitor
        properties:
          contentType: Monitor
          evaluationDelay: 5m
          isDisabled: false
          monitorType: Slo
          sloId: '0000000000000009'
          tags:
            application: sumologic
            team: monitoring
          triggerConditions:
            sloBurnRateCondition:
              critical:
                burnRate:
                  - burnRateThreshold: 50
                    timeRange: 1d
              warning:
                burnRate:
                  - burnRateThreshold: 30
                    timeRange: 3d
                  - burnRateThreshold: 20
                    timeRange: 4d
          type: MonitorsLibraryMonitor
    

    Monitor Folders

    «««< HEAD NOTE: Monitor folders are considered a different resource from Library content folders.

    import * as pulumi from "@pulumi/pulumi";
    import * as sumologic from "@pulumi/sumologic";
    
    const tfMonitorFolder1 = new sumologic.MonitorFolder("tfMonitorFolder1", {description: "a folder for monitors"});
    
    import pulumi
    import pulumi_sumologic as sumologic
    
    tf_monitor_folder1 = sumologic.MonitorFolder("tfMonitorFolder1", description="a folder for monitors")
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using SumoLogic = Pulumi.SumoLogic;
    
    return await Deployment.RunAsync(() => 
    {
        var tfMonitorFolder1 = new SumoLogic.MonitorFolder("tfMonitorFolder1", new()
        {
            Description = "a folder for monitors",
        });
    
    });
    
    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.NewMonitorFolder(ctx, "tfMonitorFolder1", &sumologic.MonitorFolderArgs{
    			Description: pulumi.String("a folder for monitors"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.sumologic.MonitorFolder;
    import com.pulumi.sumologic.MonitorFolderArgs;
    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 tfMonitorFolder1 = new MonitorFolder("tfMonitorFolder1", MonitorFolderArgs.builder()        
                .description("a folder for monitors")
                .build());
    
        }
    }
    
    resources:
      tfMonitorFolder1:
        type: sumologic:MonitorFolder
        properties:
          description: a folder for monitors
    

    ======= NOTE: Monitor folders are considered a different resource from Library content folders. See [sumologic.MonitorFolder][2] for more details.

    v2.11.0

    The trigger_conditions block

    A trigger_conditions block configures conditions for sending notifications.

    Example

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    
    return await Deployment.RunAsync(() => 
    {
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    

    Arguments

    A trigger_conditions block contains one or more subblocks of the following types:

    • logs_static_condition
    • metrics_static_condition
    • logs_outlier_condition
    • metrics_outlier_condition
    • logs_missing_data_condition
    • metrics_missing_data_condition
    • slo_sli_condition
    • slo_burn_rate_condition

    Subblocks should be limited to at most 1 missing data condition and at most 1 static / outlier condition.

    Here is a summary of arguments for each condition type (fields which are not marked as Required are optional):

    logs_static_condition

    • field
    • critical
      • time_range (Required) : Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.
      • alert (Required)
        • threshold
        • threshold_type
      • resolution (Required)
        • threshold
        • threshold_type
        • resolution_window Accepted format: <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 0s, 30m.
    • warning
      • time_range (Required) : Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.
      • alert (Required)
        • threshold
        • threshold_type
      • resolution (Required)
        • threshold
        • threshold_type
        • resolution_window Accepted format: <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 0s, 30m.

    metrics_static_condition

    • critical
      • time_range (Required) : Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.
      • occurrence_type (Required)
      • alert (Required)
        • threshold
        • threshold_type
        • min_data_points (Optional)
      • resolution (Required)
        • threshold
        • threshold_type
        • min_data_points (Optional)
      • warning
      • time_range (Required) : Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.
      • occurrence_type (Required)
      • alert (Required)
        • threshold
        • threshold_type
        • min_data_points (Optional)
      • resolution (Required)
        • threshold
        • threshold_type
        • min_data_points (Optional)

    logs_outlier_condition

    • field
    • direction
    • critical
      • window
      • consecutive
      • threshold
    • warning
      • window
      • consecutive
      • threshold

    metrics_outlier_condition

    • direction
    • critical
      • baseline_window
      • threshold
    • warning
      • baseline_window
      • threshold

    logs_missing_data_condition

    • time_range (Required) : Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.

    metrics_missing_data_condition

    • time_range (Required) : Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.

    slo_sli_condition

    • critical
      • sli_threshold (Required) : The remaining SLI error budget threshold percentage [0,100).
    • warning
      • sli_threshold (Required)

    slo_burn_rate_condition

    • critical
      • time_range (Deprecated) : The relative time range for the burn rate percentage evaluation. Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.
      • burn_rate_threshold (Deprecated) : The burn rate percentage threshold.
      • burn_rate (Required if above two fields are not present): Block to specify burn rate threshold and time range for the condition.
        • burn_rate_threshold (Required): The burn rate percentage threshold.
        • time_range (Required): The relative time range for the burn rate percentage evaluation. Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.
    • warning
      • time_range (Deprecated) : Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.
      • burn_rate_threshold (Deprecated)
      • burn_rate (Required if above two fields are not present): Block to specify burn rate threshold and time range for the condition.
        • burn_rate_threshold (Required): The burn rate percentage threshold.
        • time_range (Required): The relative time range for the burn rate percentage evaluation. Accepted format: Optional - sign followed by <number> followed by a <time_unit> character: s for seconds, m for minutes, h for hours, d for days. Examples: 30m, -12h.

    The triggers block

    The triggers block is deprecated. Please use trigger_conditions to specify notification conditions.

    Here’s an example logs monitor that uses triggers to specify trigger conditions:

    import * as pulumi from "@pulumi/pulumi";
    import * as sumologic from "@pulumi/sumologic";
    
    const tfLogsMonitor1 = new sumologic.Monitor("tfLogsMonitor1", {
        contentType: "Monitor",
        description: "tf logs monitor",
        isDisabled: false,
        monitorType: "Logs",
        notifications: [
            {
                notification: {
                    connectionType: "Email",
                    messageBody: "Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}",
                    recipients: ["abc@example.com"],
                    subject: "Monitor Alert: {{TriggerType}} on {{Name}}",
                    timeZone: "PST",
                },
                runForTriggerTypes: [
                    "Critical",
                    "ResolvedCritical",
                ],
            },
            {
                notification: {
                    connectionId: "0000000000ABC123",
                    connectionType: "Webhook",
                },
                runForTriggerTypes: [
                    "Critical",
                    "ResolvedCritical",
                ],
            },
        ],
        queries: [{
            query: "_sourceCategory=event-action info",
            rowId: "A",
        }],
        triggers: [
            {
                detectionMethod: "StaticCondition",
                occurrenceType: "ResultCount",
                threshold: 40,
                thresholdType: "GreaterThan",
                timeRange: "15m",
                triggerSource: "AllResults",
                triggerType: "Critical",
            },
            {
                detectionMethod: "StaticCondition",
                occurrenceType: "ResultCount",
                resolutionWindow: "5m",
                threshold: 40,
                thresholdType: "LessThanOrEqual",
                timeRange: "15m",
                triggerSource: "AllResults",
                triggerType: "ResolvedCritical",
            },
        ],
        type: "MonitorsLibraryMonitor",
    });
    
    import pulumi
    import pulumi_sumologic as sumologic
    
    tf_logs_monitor1 = sumologic.Monitor("tfLogsMonitor1",
        content_type="Monitor",
        description="tf logs monitor",
        is_disabled=False,
        monitor_type="Logs",
        notifications=[
            sumologic.MonitorNotificationArgs(
                notification=sumologic.MonitorNotificationNotificationArgs(
                    connection_type="Email",
                    message_body="Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}",
                    recipients=["abc@example.com"],
                    subject="Monitor Alert: {{TriggerType}} on {{Name}}",
                    time_zone="PST",
                ),
                run_for_trigger_types=[
                    "Critical",
                    "ResolvedCritical",
                ],
            ),
            sumologic.MonitorNotificationArgs(
                notification=sumologic.MonitorNotificationNotificationArgs(
                    connection_id="0000000000ABC123",
                    connection_type="Webhook",
                ),
                run_for_trigger_types=[
                    "Critical",
                    "ResolvedCritical",
                ],
            ),
        ],
        queries=[sumologic.MonitorQueryArgs(
            query="_sourceCategory=event-action info",
            row_id="A",
        )],
        triggers=[
            sumologic.MonitorTriggerArgs(
                detection_method="StaticCondition",
                occurrence_type="ResultCount",
                threshold=40,
                threshold_type="GreaterThan",
                time_range="15m",
                trigger_source="AllResults",
                trigger_type="Critical",
            ),
            sumologic.MonitorTriggerArgs(
                detection_method="StaticCondition",
                occurrence_type="ResultCount",
                resolution_window="5m",
                threshold=40,
                threshold_type="LessThanOrEqual",
                time_range="15m",
                trigger_source="AllResults",
                trigger_type="ResolvedCritical",
            ),
        ],
        type="MonitorsLibraryMonitor")
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using SumoLogic = Pulumi.SumoLogic;
    
    return await Deployment.RunAsync(() => 
    {
        var tfLogsMonitor1 = new SumoLogic.Monitor("tfLogsMonitor1", new()
        {
            ContentType = "Monitor",
            Description = "tf logs monitor",
            IsDisabled = false,
            MonitorType = "Logs",
            Notifications = new[]
            {
                new SumoLogic.Inputs.MonitorNotificationArgs
                {
                    Notification = new SumoLogic.Inputs.MonitorNotificationNotificationArgs
                    {
                        ConnectionType = "Email",
                        MessageBody = "Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}",
                        Recipients = new[]
                        {
                            "abc@example.com",
                        },
                        Subject = "Monitor Alert: {{TriggerType}} on {{Name}}",
                        TimeZone = "PST",
                    },
                    RunForTriggerTypes = new[]
                    {
                        "Critical",
                        "ResolvedCritical",
                    },
                },
                new SumoLogic.Inputs.MonitorNotificationArgs
                {
                    Notification = new SumoLogic.Inputs.MonitorNotificationNotificationArgs
                    {
                        ConnectionId = "0000000000ABC123",
                        ConnectionType = "Webhook",
                    },
                    RunForTriggerTypes = new[]
                    {
                        "Critical",
                        "ResolvedCritical",
                    },
                },
            },
            Queries = new[]
            {
                new SumoLogic.Inputs.MonitorQueryArgs
                {
                    Query = "_sourceCategory=event-action info",
                    RowId = "A",
                },
            },
            Triggers = new[]
            {
                new SumoLogic.Inputs.MonitorTriggerArgs
                {
                    DetectionMethod = "StaticCondition",
                    OccurrenceType = "ResultCount",
                    Threshold = 40,
                    ThresholdType = "GreaterThan",
                    TimeRange = "15m",
                    TriggerSource = "AllResults",
                    TriggerType = "Critical",
                },
                new SumoLogic.Inputs.MonitorTriggerArgs
                {
                    DetectionMethod = "StaticCondition",
                    OccurrenceType = "ResultCount",
                    ResolutionWindow = "5m",
                    Threshold = 40,
                    ThresholdType = "LessThanOrEqual",
                    TimeRange = "15m",
                    TriggerSource = "AllResults",
                    TriggerType = "ResolvedCritical",
                },
            },
            Type = "MonitorsLibraryMonitor",
        });
    
    });
    
    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.NewMonitor(ctx, "tfLogsMonitor1", &sumologic.MonitorArgs{
    			ContentType: pulumi.String("Monitor"),
    			Description: pulumi.String("tf logs monitor"),
    			IsDisabled:  pulumi.Bool(false),
    			MonitorType: pulumi.String("Logs"),
    			Notifications: sumologic.MonitorNotificationArray{
    				&sumologic.MonitorNotificationArgs{
    					Notification: &sumologic.MonitorNotificationNotificationArgs{
    						ConnectionType: pulumi.String("Email"),
    						MessageBody:    pulumi.String("Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}"),
    						Recipients: pulumi.StringArray{
    							pulumi.String("abc@example.com"),
    						},
    						Subject:  pulumi.String("Monitor Alert: {{TriggerType}} on {{Name}}"),
    						TimeZone: pulumi.String("PST"),
    					},
    					RunForTriggerTypes: pulumi.StringArray{
    						pulumi.String("Critical"),
    						pulumi.String("ResolvedCritical"),
    					},
    				},
    				&sumologic.MonitorNotificationArgs{
    					Notification: &sumologic.MonitorNotificationNotificationArgs{
    						ConnectionId:   pulumi.String("0000000000ABC123"),
    						ConnectionType: pulumi.String("Webhook"),
    					},
    					RunForTriggerTypes: pulumi.StringArray{
    						pulumi.String("Critical"),
    						pulumi.String("ResolvedCritical"),
    					},
    				},
    			},
    			Queries: sumologic.MonitorQueryArray{
    				&sumologic.MonitorQueryArgs{
    					Query: pulumi.String("_sourceCategory=event-action info"),
    					RowId: pulumi.String("A"),
    				},
    			},
    			Triggers: sumologic.MonitorTriggerArray{
    				&sumologic.MonitorTriggerArgs{
    					DetectionMethod: pulumi.String("StaticCondition"),
    					OccurrenceType:  pulumi.String("ResultCount"),
    					Threshold:       pulumi.Float64(40),
    					ThresholdType:   pulumi.String("GreaterThan"),
    					TimeRange:       pulumi.String("15m"),
    					TriggerSource:   pulumi.String("AllResults"),
    					TriggerType:     pulumi.String("Critical"),
    				},
    				&sumologic.MonitorTriggerArgs{
    					DetectionMethod:  pulumi.String("StaticCondition"),
    					OccurrenceType:   pulumi.String("ResultCount"),
    					ResolutionWindow: pulumi.String("5m"),
    					Threshold:        pulumi.Float64(40),
    					ThresholdType:    pulumi.String("LessThanOrEqual"),
    					TimeRange:        pulumi.String("15m"),
    					TriggerSource:    pulumi.String("AllResults"),
    					TriggerType:      pulumi.String("ResolvedCritical"),
    				},
    			},
    			Type: pulumi.String("MonitorsLibraryMonitor"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.sumologic.Monitor;
    import com.pulumi.sumologic.MonitorArgs;
    import com.pulumi.sumologic.inputs.MonitorNotificationArgs;
    import com.pulumi.sumologic.inputs.MonitorNotificationNotificationArgs;
    import com.pulumi.sumologic.inputs.MonitorQueryArgs;
    import com.pulumi.sumologic.inputs.MonitorTriggerArgs;
    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 tfLogsMonitor1 = new Monitor("tfLogsMonitor1", MonitorArgs.builder()        
                .contentType("Monitor")
                .description("tf logs monitor")
                .isDisabled(false)
                .monitorType("Logs")
                .notifications(            
                    MonitorNotificationArgs.builder()
                        .notification(MonitorNotificationNotificationArgs.builder()
                            .connectionType("Email")
                            .messageBody("Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}")
                            .recipients("abc@example.com")
                            .subject("Monitor Alert: {{TriggerType}} on {{Name}}")
                            .timeZone("PST")
                            .build())
                        .runForTriggerTypes(                    
                            "Critical",
                            "ResolvedCritical")
                        .build(),
                    MonitorNotificationArgs.builder()
                        .notification(MonitorNotificationNotificationArgs.builder()
                            .connectionId("0000000000ABC123")
                            .connectionType("Webhook")
                            .build())
                        .runForTriggerTypes(                    
                            "Critical",
                            "ResolvedCritical")
                        .build())
                .queries(MonitorQueryArgs.builder()
                    .query("_sourceCategory=event-action info")
                    .rowId("A")
                    .build())
                .triggers(            
                    MonitorTriggerArgs.builder()
                        .detectionMethod("StaticCondition")
                        .occurrenceType("ResultCount")
                        .threshold(40)
                        .thresholdType("GreaterThan")
                        .timeRange("15m")
                        .triggerSource("AllResults")
                        .triggerType("Critical")
                        .build(),
                    MonitorTriggerArgs.builder()
                        .detectionMethod("StaticCondition")
                        .occurrenceType("ResultCount")
                        .resolutionWindow("5m")
                        .threshold(40)
                        .thresholdType("LessThanOrEqual")
                        .timeRange("15m")
                        .triggerSource("AllResults")
                        .triggerType("ResolvedCritical")
                        .build())
                .type("MonitorsLibraryMonitor")
                .build());
    
        }
    }
    
    resources:
      tfLogsMonitor1:
        type: sumologic:Monitor
        properties:
          contentType: Monitor
          description: tf logs monitor
          isDisabled: false
          monitorType: Logs
          notifications:
            - notification:
                connectionType: Email
                messageBody: 'Triggered {{TriggerType}} Alert on {{Name}}: {{QueryURL}}'
                recipients:
                  - abc@example.com
                subject: 'Monitor Alert: {{TriggerType}} on {{Name}}'
                timeZone: PST
              runForTriggerTypes:
                - Critical
                - ResolvedCritical
            - notification:
                connectionId: 0000000000ABC123
                connectionType: Webhook
              runForTriggerTypes:
                - Critical
                - ResolvedCritical
          queries:
            - query: _sourceCategory=event-action info
              rowId: A
          triggers:
            - detectionMethod: StaticCondition
              occurrenceType: ResultCount
              threshold: 40
              thresholdType: GreaterThan
              timeRange: 15m
              triggerSource: AllResults
              triggerType: Critical
            - detectionMethod: StaticCondition
              occurrenceType: ResultCount
              resolutionWindow: 5m
              threshold: 40
              thresholdType: LessThanOrEqual
              timeRange: 15m
              triggerSource: AllResults
              triggerType: ResolvedCritical
          type: MonitorsLibraryMonitor
    

    Create Monitor Resource

    new Monitor(name: string, args: MonitorArgs, opts?: CustomResourceOptions);
    @overload
    def Monitor(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                alert_name: Optional[str] = None,
                content_type: Optional[str] = None,
                created_at: Optional[str] = None,
                created_by: Optional[str] = None,
                description: Optional[str] = None,
                evaluation_delay: Optional[str] = None,
                group_notifications: Optional[bool] = None,
                is_disabled: Optional[bool] = None,
                is_locked: Optional[bool] = None,
                is_mutable: Optional[bool] = None,
                is_system: Optional[bool] = None,
                modified_at: Optional[str] = None,
                modified_by: Optional[str] = None,
                monitor_type: Optional[str] = None,
                name: Optional[str] = None,
                notification_group_fields: Optional[Sequence[str]] = None,
                notifications: Optional[Sequence[MonitorNotificationArgs]] = None,
                obj_permissions: Optional[Sequence[MonitorObjPermissionArgs]] = None,
                parent_id: Optional[str] = None,
                playbook: Optional[str] = None,
                post_request_map: Optional[Mapping[str, str]] = None,
                queries: Optional[Sequence[MonitorQueryArgs]] = None,
                slo_id: Optional[str] = None,
                statuses: Optional[Sequence[str]] = None,
                tags: Optional[Mapping[str, str]] = None,
                time_zone: Optional[str] = None,
                trigger_conditions: Optional[MonitorTriggerConditionsArgs] = None,
                triggers: Optional[Sequence[MonitorTriggerArgs]] = None,
                type: Optional[str] = None,
                version: Optional[int] = None)
    @overload
    def Monitor(resource_name: str,
                args: MonitorArgs,
                opts: Optional[ResourceOptions] = None)
    func NewMonitor(ctx *Context, name string, args MonitorArgs, opts ...ResourceOption) (*Monitor, error)
    public Monitor(string name, MonitorArgs args, CustomResourceOptions? opts = null)
    public Monitor(String name, MonitorArgs args)
    public Monitor(String name, MonitorArgs args, CustomResourceOptions options)
    
    type: sumologic:Monitor
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    name string
    The unique name of the resource.
    args MonitorArgs
    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 MonitorArgs
    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 MonitorArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args MonitorArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args MonitorArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Monitor Resource Properties

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

    Inputs

    The Monitor resource accepts the following input properties:

    MonitorType string
    The type of monitor. Valid values:
    AlertName string
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    ContentType string
    The type of the content object. Valid value:
    CreatedAt string
    CreatedBy string
    Description string
    The description of the monitor.
    EvaluationDelay string

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    GroupNotifications bool
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    IsDisabled bool
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    IsLocked bool
    IsMutable bool
    IsSystem bool
    ModifiedAt string
    ModifiedBy string
    Name string
    The name of the monitor. The name must be alphanumeric.
    NotificationGroupFields List<string>
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    Notifications List<Pulumi.SumoLogic.Inputs.MonitorNotification>
    The notifications the monitor will send when the respective trigger condition is met.
    ObjPermissions List<Pulumi.SumoLogic.Inputs.MonitorObjPermission>
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    ParentId string
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    Playbook string
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    PostRequestMap Dictionary<string, string>
    Queries List<Pulumi.SumoLogic.Inputs.MonitorQuery>
    All queries from the monitor.
    SloId string
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    Statuses List<string>
    The current status for this monitor. Values are:
    Tags Dictionary<string, string>
    A map defining tag keys and tag values for the Monitor.
    TimeZone string
    TriggerConditions Pulumi.SumoLogic.Inputs.MonitorTriggerConditions
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    Triggers List<Pulumi.SumoLogic.Inputs.MonitorTrigger>
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    Type string
    The type of object model. Valid value:
    Version int
    MonitorType string
    The type of monitor. Valid values:
    AlertName string
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    ContentType string
    The type of the content object. Valid value:
    CreatedAt string
    CreatedBy string
    Description string
    The description of the monitor.
    EvaluationDelay string

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    GroupNotifications bool
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    IsDisabled bool
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    IsLocked bool
    IsMutable bool
    IsSystem bool
    ModifiedAt string
    ModifiedBy string
    Name string
    The name of the monitor. The name must be alphanumeric.
    NotificationGroupFields []string
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    Notifications []MonitorNotificationArgs
    The notifications the monitor will send when the respective trigger condition is met.
    ObjPermissions []MonitorObjPermissionArgs
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    ParentId string
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    Playbook string
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    PostRequestMap map[string]string
    Queries []MonitorQueryArgs
    All queries from the monitor.
    SloId string
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    Statuses []string
    The current status for this monitor. Values are:
    Tags map[string]string
    A map defining tag keys and tag values for the Monitor.
    TimeZone string
    TriggerConditions MonitorTriggerConditionsArgs
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    Triggers []MonitorTriggerArgs
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    Type string
    The type of object model. Valid value:
    Version int
    monitorType String
    The type of monitor. Valid values:
    alertName String
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    contentType String
    The type of the content object. Valid value:
    createdAt String
    createdBy String
    description String
    The description of the monitor.
    evaluationDelay String

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    groupNotifications Boolean
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    isDisabled Boolean
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    isLocked Boolean
    isMutable Boolean
    isSystem Boolean
    modifiedAt String
    modifiedBy String
    name String
    The name of the monitor. The name must be alphanumeric.
    notificationGroupFields List<String>
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications List<MonitorNotification>
    The notifications the monitor will send when the respective trigger condition is met.
    objPermissions List<MonitorObjPermission>
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parentId String
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook String
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    postRequestMap Map<String,String>
    queries List<MonitorQuery>
    All queries from the monitor.
    sloId String
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses List<String>
    The current status for this monitor. Values are:
    tags Map<String,String>
    A map defining tag keys and tag values for the Monitor.
    timeZone String
    triggerConditions MonitorTriggerConditions
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers List<MonitorTrigger>
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type String
    The type of object model. Valid value:
    version Integer
    monitorType string
    The type of monitor. Valid values:
    alertName string
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    contentType string
    The type of the content object. Valid value:
    createdAt string
    createdBy string
    description string
    The description of the monitor.
    evaluationDelay string

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    groupNotifications boolean
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    isDisabled boolean
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    isLocked boolean
    isMutable boolean
    isSystem boolean
    modifiedAt string
    modifiedBy string
    name string
    The name of the monitor. The name must be alphanumeric.
    notificationGroupFields string[]
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications MonitorNotification[]
    The notifications the monitor will send when the respective trigger condition is met.
    objPermissions MonitorObjPermission[]
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parentId string
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook string
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    postRequestMap {[key: string]: string}
    queries MonitorQuery[]
    All queries from the monitor.
    sloId string
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses string[]
    The current status for this monitor. Values are:
    tags {[key: string]: string}
    A map defining tag keys and tag values for the Monitor.
    timeZone string
    triggerConditions MonitorTriggerConditions
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers MonitorTrigger[]
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type string
    The type of object model. Valid value:
    version number
    monitor_type str
    The type of monitor. Valid values:
    alert_name str
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    content_type str
    The type of the content object. Valid value:
    created_at str
    created_by str
    description str
    The description of the monitor.
    evaluation_delay str

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    group_notifications bool
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    is_disabled bool
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    is_locked bool
    is_mutable bool
    is_system bool
    modified_at str
    modified_by str
    name str
    The name of the monitor. The name must be alphanumeric.
    notification_group_fields Sequence[str]
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications Sequence[MonitorNotificationArgs]
    The notifications the monitor will send when the respective trigger condition is met.
    obj_permissions Sequence[MonitorObjPermissionArgs]
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parent_id str
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook str
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    post_request_map Mapping[str, str]
    queries Sequence[MonitorQueryArgs]
    All queries from the monitor.
    slo_id str
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses Sequence[str]
    The current status for this monitor. Values are:
    tags Mapping[str, str]
    A map defining tag keys and tag values for the Monitor.
    time_zone str
    trigger_conditions MonitorTriggerConditionsArgs
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers Sequence[MonitorTriggerArgs]
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type str
    The type of object model. Valid value:
    version int
    monitorType String
    The type of monitor. Valid values:
    alertName String
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    contentType String
    The type of the content object. Valid value:
    createdAt String
    createdBy String
    description String
    The description of the monitor.
    evaluationDelay String

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    groupNotifications Boolean
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    isDisabled Boolean
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    isLocked Boolean
    isMutable Boolean
    isSystem Boolean
    modifiedAt String
    modifiedBy String
    name String
    The name of the monitor. The name must be alphanumeric.
    notificationGroupFields List<String>
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications List<Property Map>
    The notifications the monitor will send when the respective trigger condition is met.
    objPermissions List<Property Map>
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parentId String
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook String
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    postRequestMap Map<String>
    queries List<Property Map>
    All queries from the monitor.
    sloId String
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses List<String>
    The current status for this monitor. Values are:
    tags Map<String>
    A map defining tag keys and tag values for the Monitor.
    timeZone String
    triggerConditions Property Map
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers List<Property Map>
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type String
    The type of object model. Valid value:
    version Number

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Monitor 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 str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing Monitor Resource

    Get an existing Monitor 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?: MonitorState, opts?: CustomResourceOptions): Monitor
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            alert_name: Optional[str] = None,
            content_type: Optional[str] = None,
            created_at: Optional[str] = None,
            created_by: Optional[str] = None,
            description: Optional[str] = None,
            evaluation_delay: Optional[str] = None,
            group_notifications: Optional[bool] = None,
            is_disabled: Optional[bool] = None,
            is_locked: Optional[bool] = None,
            is_mutable: Optional[bool] = None,
            is_system: Optional[bool] = None,
            modified_at: Optional[str] = None,
            modified_by: Optional[str] = None,
            monitor_type: Optional[str] = None,
            name: Optional[str] = None,
            notification_group_fields: Optional[Sequence[str]] = None,
            notifications: Optional[Sequence[MonitorNotificationArgs]] = None,
            obj_permissions: Optional[Sequence[MonitorObjPermissionArgs]] = None,
            parent_id: Optional[str] = None,
            playbook: Optional[str] = None,
            post_request_map: Optional[Mapping[str, str]] = None,
            queries: Optional[Sequence[MonitorQueryArgs]] = None,
            slo_id: Optional[str] = None,
            statuses: Optional[Sequence[str]] = None,
            tags: Optional[Mapping[str, str]] = None,
            time_zone: Optional[str] = None,
            trigger_conditions: Optional[MonitorTriggerConditionsArgs] = None,
            triggers: Optional[Sequence[MonitorTriggerArgs]] = None,
            type: Optional[str] = None,
            version: Optional[int] = None) -> Monitor
    func GetMonitor(ctx *Context, name string, id IDInput, state *MonitorState, opts ...ResourceOption) (*Monitor, error)
    public static Monitor Get(string name, Input<string> id, MonitorState? state, CustomResourceOptions? opts = null)
    public static Monitor get(String name, Output<String> id, MonitorState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    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:
    AlertName string
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    ContentType string
    The type of the content object. Valid value:
    CreatedAt string
    CreatedBy string
    Description string
    The description of the monitor.
    EvaluationDelay string

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    GroupNotifications bool
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    IsDisabled bool
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    IsLocked bool
    IsMutable bool
    IsSystem bool
    ModifiedAt string
    ModifiedBy string
    MonitorType string
    The type of monitor. Valid values:
    Name string
    The name of the monitor. The name must be alphanumeric.
    NotificationGroupFields List<string>
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    Notifications List<Pulumi.SumoLogic.Inputs.MonitorNotification>
    The notifications the monitor will send when the respective trigger condition is met.
    ObjPermissions List<Pulumi.SumoLogic.Inputs.MonitorObjPermission>
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    ParentId string
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    Playbook string
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    PostRequestMap Dictionary<string, string>
    Queries List<Pulumi.SumoLogic.Inputs.MonitorQuery>
    All queries from the monitor.
    SloId string
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    Statuses List<string>
    The current status for this monitor. Values are:
    Tags Dictionary<string, string>
    A map defining tag keys and tag values for the Monitor.
    TimeZone string
    TriggerConditions Pulumi.SumoLogic.Inputs.MonitorTriggerConditions
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    Triggers List<Pulumi.SumoLogic.Inputs.MonitorTrigger>
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    Type string
    The type of object model. Valid value:
    Version int
    AlertName string
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    ContentType string
    The type of the content object. Valid value:
    CreatedAt string
    CreatedBy string
    Description string
    The description of the monitor.
    EvaluationDelay string

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    GroupNotifications bool
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    IsDisabled bool
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    IsLocked bool
    IsMutable bool
    IsSystem bool
    ModifiedAt string
    ModifiedBy string
    MonitorType string
    The type of monitor. Valid values:
    Name string
    The name of the monitor. The name must be alphanumeric.
    NotificationGroupFields []string
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    Notifications []MonitorNotificationArgs
    The notifications the monitor will send when the respective trigger condition is met.
    ObjPermissions []MonitorObjPermissionArgs
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    ParentId string
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    Playbook string
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    PostRequestMap map[string]string
    Queries []MonitorQueryArgs
    All queries from the monitor.
    SloId string
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    Statuses []string
    The current status for this monitor. Values are:
    Tags map[string]string
    A map defining tag keys and tag values for the Monitor.
    TimeZone string
    TriggerConditions MonitorTriggerConditionsArgs
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    Triggers []MonitorTriggerArgs
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    Type string
    The type of object model. Valid value:
    Version int
    alertName String
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    contentType String
    The type of the content object. Valid value:
    createdAt String
    createdBy String
    description String
    The description of the monitor.
    evaluationDelay String

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    groupNotifications Boolean
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    isDisabled Boolean
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    isLocked Boolean
    isMutable Boolean
    isSystem Boolean
    modifiedAt String
    modifiedBy String
    monitorType String
    The type of monitor. Valid values:
    name String
    The name of the monitor. The name must be alphanumeric.
    notificationGroupFields List<String>
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications List<MonitorNotification>
    The notifications the monitor will send when the respective trigger condition is met.
    objPermissions List<MonitorObjPermission>
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parentId String
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook String
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    postRequestMap Map<String,String>
    queries List<MonitorQuery>
    All queries from the monitor.
    sloId String
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses List<String>
    The current status for this monitor. Values are:
    tags Map<String,String>
    A map defining tag keys and tag values for the Monitor.
    timeZone String
    triggerConditions MonitorTriggerConditions
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers List<MonitorTrigger>
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type String
    The type of object model. Valid value:
    version Integer
    alertName string
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    contentType string
    The type of the content object. Valid value:
    createdAt string
    createdBy string
    description string
    The description of the monitor.
    evaluationDelay string

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    groupNotifications boolean
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    isDisabled boolean
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    isLocked boolean
    isMutable boolean
    isSystem boolean
    modifiedAt string
    modifiedBy string
    monitorType string
    The type of monitor. Valid values:
    name string
    The name of the monitor. The name must be alphanumeric.
    notificationGroupFields string[]
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications MonitorNotification[]
    The notifications the monitor will send when the respective trigger condition is met.
    objPermissions MonitorObjPermission[]
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parentId string
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook string
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    postRequestMap {[key: string]: string}
    queries MonitorQuery[]
    All queries from the monitor.
    sloId string
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses string[]
    The current status for this monitor. Values are:
    tags {[key: string]: string}
    A map defining tag keys and tag values for the Monitor.
    timeZone string
    triggerConditions MonitorTriggerConditions
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers MonitorTrigger[]
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type string
    The type of object model. Valid value:
    version number
    alert_name str
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    content_type str
    The type of the content object. Valid value:
    created_at str
    created_by str
    description str
    The description of the monitor.
    evaluation_delay str

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    group_notifications bool
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    is_disabled bool
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    is_locked bool
    is_mutable bool
    is_system bool
    modified_at str
    modified_by str
    monitor_type str
    The type of monitor. Valid values:
    name str
    The name of the monitor. The name must be alphanumeric.
    notification_group_fields Sequence[str]
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications Sequence[MonitorNotificationArgs]
    The notifications the monitor will send when the respective trigger condition is met.
    obj_permissions Sequence[MonitorObjPermissionArgs]
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parent_id str
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook str
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    post_request_map Mapping[str, str]
    queries Sequence[MonitorQueryArgs]
    All queries from the monitor.
    slo_id str
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses Sequence[str]
    The current status for this monitor. Values are:
    tags Mapping[str, str]
    A map defining tag keys and tag values for the Monitor.
    time_zone str
    trigger_conditions MonitorTriggerConditionsArgs
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers Sequence[MonitorTriggerArgs]
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type str
    The type of object model. Valid value:
    version int
    alertName String
    The display name when creating alerts. Monitor name will be used if alert_name is not provided. All template variables can be used in alert_name except {{AlertName}}, {{AlertResponseURL}}, {{ResultsJson}}, and {{Playbook}}.
    contentType String
    The type of the content object. Valid value:
    createdAt String
    createdBy String
    description String
    The description of the monitor.
    evaluationDelay String

    Evaluation delay as a string consists of the following elements:

    1. <number>: number of time units,
    2. <time_unit>: time unit; possible values are: h (hour), m (minute), s (second).

    Multiple pairs of <number><time_unit> may be provided. For example, 2m50s means 2 minutes and 50 seconds.

    groupNotifications Boolean
    Whether or not to group notifications for individual items that meet the trigger condition. Defaults to true.
    isDisabled Boolean
    Whether or not the monitor is disabled. Disabled monitors will not run and will not generate or send notifications.
    isLocked Boolean
    isMutable Boolean
    isSystem Boolean
    modifiedAt String
    modifiedBy String
    monitorType String
    The type of monitor. Valid values:
    name String
    The name of the monitor. The name must be alphanumeric.
    notificationGroupFields List<String>
    The set of fields to be used to group alerts and notifications for a monitor. The value of this field will be considered only when 'groupNotifications' is true. The fields with very high cardinality such as _blockid, _raw, _messagetime, _receipttime, and _messageid are not allowed for Alert Grouping.
    notifications List<Property Map>
    The notifications the monitor will send when the respective trigger condition is met.
    objPermissions List<Property Map>
    obj_permission construct represents a Permission Statement associated with this Monitor. A set of obj_permission constructs can be specified under a Monitor. An obj_permission construct can be used to control permissions Explicitly associated with a Monitor. But, it cannot be used to control permissions Inherited from a Parent / Ancestor. Default FGP would be still set to the Monitor upon creation (e.g. the creating user would have full permission), even if no obj_permission construct is specified at a Monitor and the FGP feature is enabled at the account.
    parentId String
    The ID of the Monitor Folder that contains this monitor. Defaults to the root folder.
    playbook String
    Notes such as links and instruction to help you resolve alerts triggered by this monitor. {{Markdown}} supported. It will be enabled only if available for your organization. Please contact your Sumo Logic account team to learn more.
    postRequestMap Map<String>
    queries List<Property Map>
    All queries from the monitor.
    sloId String
    Identifier of the SLO definition for the monitor. This is only applicable & required for Slo monitor_type.
    statuses List<String>
    The current status for this monitor. Values are:
    tags Map<String>
    A map defining tag keys and tag values for the Monitor.
    timeZone String
    triggerConditions Property Map
    Defines the conditions of when to send notifications. NOTE: trigger_conditions supplants the triggers argument.
    triggers List<Property Map>
    Defines the conditions of when to send notifications.

    Deprecated:The field triggers is deprecated and will be removed in a future release of the provider -- please use trigger_conditions instead.

    type String
    The type of object model. Valid value:
    version Number

    Supporting Types

    MonitorNotification, MonitorNotificationArgs

    MonitorNotificationNotification, MonitorNotificationNotificationArgs

    ActionType string

    Deprecated:The field action_type is deprecated and will be removed in a future release of the provider - please use connection_type instead.

    ConnectionId string
    ConnectionType string
    MessageBody string
    PayloadOverride string
    Recipients List<string>
    ResolutionPayloadOverride string
    Subject string
    TimeZone string
    ActionType string

    Deprecated:The field action_type is deprecated and will be removed in a future release of the provider - please use connection_type instead.

    ConnectionId string
    ConnectionType string
    MessageBody string
    PayloadOverride string
    Recipients []string
    ResolutionPayloadOverride string
    Subject string
    TimeZone string
    actionType String

    Deprecated:The field action_type is deprecated and will be removed in a future release of the provider - please use connection_type instead.

    connectionId String
    connectionType String
    messageBody String
    payloadOverride String
    recipients List<String>
    resolutionPayloadOverride String
    subject String
    timeZone String
    actionType string

    Deprecated:The field action_type is deprecated and will be removed in a future release of the provider - please use connection_type instead.

    connectionId string
    connectionType string
    messageBody string
    payloadOverride string
    recipients string[]
    resolutionPayloadOverride string
    subject string
    timeZone string
    action_type str

    Deprecated:The field action_type is deprecated and will be removed in a future release of the provider - please use connection_type instead.

    connection_id str
    connection_type str
    message_body str
    payload_override str
    recipients Sequence[str]
    resolution_payload_override str
    subject str
    time_zone str
    actionType String

    Deprecated:The field action_type is deprecated and will be removed in a future release of the provider - please use connection_type instead.

    connectionId String
    connectionType String
    messageBody String
    payloadOverride String
    recipients List<String>
    resolutionPayloadOverride String
    subject String
    timeZone String

    MonitorObjPermission, MonitorObjPermissionArgs

    Permissions List<string>
    A Set of Permissions. Valid Permission Values:
    SubjectId string
    A Role ID or the Org ID of the account
    SubjectType string
    Valid values:
    Permissions []string
    A Set of Permissions. Valid Permission Values:
    SubjectId string
    A Role ID or the Org ID of the account
    SubjectType string
    Valid values:
    permissions List<String>
    A Set of Permissions. Valid Permission Values:
    subjectId String
    A Role ID or the Org ID of the account
    subjectType String
    Valid values:
    permissions string[]
    A Set of Permissions. Valid Permission Values:
    subjectId string
    A Role ID or the Org ID of the account
    subjectType string
    Valid values:
    permissions Sequence[str]
    A Set of Permissions. Valid Permission Values:
    subject_id str
    A Role ID or the Org ID of the account
    subject_type str
    Valid values:
    permissions List<String>
    A Set of Permissions. Valid Permission Values:
    subjectId String
    A Role ID or the Org ID of the account
    subjectType String
    Valid values:

    MonitorQuery, MonitorQueryArgs

    Query string
    RowId string
    Query string
    RowId string
    query String
    rowId String
    query string
    rowId string
    query str
    row_id str
    query String
    rowId String

    MonitorTrigger, MonitorTriggerArgs

    DetectionMethod string
    MinDataPoints int
    OccurrenceType string
    ResolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    Threshold double
    ThresholdType string
    TimeRange string
    TriggerSource string
    TriggerType string
    DetectionMethod string
    MinDataPoints int
    OccurrenceType string
    ResolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    Threshold float64
    ThresholdType string
    TimeRange string
    TriggerSource string
    TriggerType string
    detectionMethod String
    minDataPoints Integer
    occurrenceType String
    resolutionWindow String
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold Double
    thresholdType String
    timeRange String
    triggerSource String
    triggerType String
    detectionMethod string
    minDataPoints number
    occurrenceType string
    resolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold number
    thresholdType string
    timeRange string
    triggerSource string
    triggerType string
    detection_method str
    min_data_points int
    occurrence_type str
    resolution_window str
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold float
    threshold_type str
    time_range str
    trigger_source str
    trigger_type str
    detectionMethod String
    minDataPoints Number
    occurrenceType String
    resolutionWindow String
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold Number
    thresholdType String
    timeRange String
    triggerSource String
    triggerType String

    MonitorTriggerConditions, MonitorTriggerConditionsArgs

    MonitorTriggerConditionsLogsMissingDataCondition, MonitorTriggerConditionsLogsMissingDataConditionArgs

    TimeRange string
    TimeRange string
    timeRange String
    timeRange string
    timeRange String

    MonitorTriggerConditionsLogsOutlierCondition, MonitorTriggerConditionsLogsOutlierConditionArgs

    MonitorTriggerConditionsLogsOutlierConditionCritical, MonitorTriggerConditionsLogsOutlierConditionCriticalArgs

    consecutive Integer
    threshold Double
    window Integer
    consecutive number
    threshold number
    window number
    consecutive Number
    threshold Number
    window Number

    MonitorTriggerConditionsLogsOutlierConditionWarning, MonitorTriggerConditionsLogsOutlierConditionWarningArgs

    consecutive Integer
    threshold Double
    window Integer
    consecutive number
    threshold number
    window number
    consecutive Number
    threshold Number
    window Number

    MonitorTriggerConditionsLogsStaticCondition, MonitorTriggerConditionsLogsStaticConditionArgs

    MonitorTriggerConditionsLogsStaticConditionCritical, MonitorTriggerConditionsLogsStaticConditionCriticalArgs

    MonitorTriggerConditionsLogsStaticConditionCriticalAlert, MonitorTriggerConditionsLogsStaticConditionCriticalAlertArgs

    Threshold float64
    ThresholdType string

    MonitorTriggerConditionsLogsStaticConditionCriticalResolution, MonitorTriggerConditionsLogsStaticConditionCriticalResolutionArgs

    ResolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    Threshold double
    ThresholdType string
    ResolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    Threshold float64
    ThresholdType string
    resolutionWindow String
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold Double
    thresholdType String
    resolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold number
    thresholdType string
    resolution_window str
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold float
    threshold_type str
    resolutionWindow String
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold Number
    thresholdType String

    MonitorTriggerConditionsLogsStaticConditionWarning, MonitorTriggerConditionsLogsStaticConditionWarningArgs

    MonitorTriggerConditionsLogsStaticConditionWarningAlert, MonitorTriggerConditionsLogsStaticConditionWarningAlertArgs

    Threshold float64
    ThresholdType string

    MonitorTriggerConditionsLogsStaticConditionWarningResolution, MonitorTriggerConditionsLogsStaticConditionWarningResolutionArgs

    ResolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    Threshold double
    ThresholdType string
    ResolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    Threshold float64
    ThresholdType string
    resolutionWindow String
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold Double
    thresholdType String
    resolutionWindow string
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold number
    thresholdType string
    resolution_window str
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold float
    threshold_type str
    resolutionWindow String
    The resolution window that the recovery condition must be met in each evaluation that happens within this entire duration before the alert is recovered (resolved). If not specified, the time range of your trigger will be used.
    threshold Number
    thresholdType String

    MonitorTriggerConditionsMetricsMissingDataCondition, MonitorTriggerConditionsMetricsMissingDataConditionArgs

    MonitorTriggerConditionsMetricsOutlierCondition, MonitorTriggerConditionsMetricsOutlierConditionArgs

    MonitorTriggerConditionsMetricsOutlierConditionCritical, MonitorTriggerConditionsMetricsOutlierConditionCriticalArgs

    MonitorTriggerConditionsMetricsOutlierConditionWarning, MonitorTriggerConditionsMetricsOutlierConditionWarningArgs

    MonitorTriggerConditionsMetricsStaticCondition, MonitorTriggerConditionsMetricsStaticConditionArgs

    MonitorTriggerConditionsMetricsStaticConditionCritical, MonitorTriggerConditionsMetricsStaticConditionCriticalArgs

    MonitorTriggerConditionsMetricsStaticConditionCriticalAlert, MonitorTriggerConditionsMetricsStaticConditionCriticalAlertArgs

    MonitorTriggerConditionsMetricsStaticConditionCriticalResolution, MonitorTriggerConditionsMetricsStaticConditionCriticalResolutionArgs

    MonitorTriggerConditionsMetricsStaticConditionWarning, MonitorTriggerConditionsMetricsStaticConditionWarningArgs

    MonitorTriggerConditionsMetricsStaticConditionWarningAlert, MonitorTriggerConditionsMetricsStaticConditionWarningAlertArgs

    MonitorTriggerConditionsMetricsStaticConditionWarningResolution, MonitorTriggerConditionsMetricsStaticConditionWarningResolutionArgs

    MonitorTriggerConditionsSloBurnRateCondition, MonitorTriggerConditionsSloBurnRateConditionArgs

    MonitorTriggerConditionsSloBurnRateConditionCritical, MonitorTriggerConditionsSloBurnRateConditionCriticalArgs

    MonitorTriggerConditionsSloBurnRateConditionCriticalBurnRate, MonitorTriggerConditionsSloBurnRateConditionCriticalBurnRateArgs

    MonitorTriggerConditionsSloBurnRateConditionWarning, MonitorTriggerConditionsSloBurnRateConditionWarningArgs

    MonitorTriggerConditionsSloBurnRateConditionWarningBurnRate, MonitorTriggerConditionsSloBurnRateConditionWarningBurnRateArgs

    MonitorTriggerConditionsSloSliCondition, MonitorTriggerConditionsSloSliConditionArgs

    MonitorTriggerConditionsSloSliConditionCritical, MonitorTriggerConditionsSloSliConditionCriticalArgs

    SliThreshold float64

    MonitorTriggerConditionsSloSliConditionWarning, MonitorTriggerConditionsSloSliConditionWarningArgs

    SliThreshold float64

    Import

    Monitors can be imported using the monitor ID, such ashcl

     $ pulumi import sumologic:index/monitor:Monitor test 1234567890
    

    [1]https://help.sumologic.com/?cid=10020 [2]monitor_folder.html.markdown [3]https://help.sumologic.com/Visualizations-and-Alerts/Alerts/Monitors#configure-permissions-for-a-monitor

    Package Details

    Repository
    Sumo Logic pulumi/pulumi-sumologic
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the sumologic Terraform Provider.
    sumologic logo
    Sumo Logic v0.20.2 published on Friday, Feb 2, 2024 by Pulumi