newrelic.Workflow

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

// Create a policy to track
const my_policy = new newrelic.AlertPolicy("my-policy", {});
// Create a reusable notification destination
const webhook_destination = new newrelic.NotificationDestination("webhook-destination", {
    type: "WEBHOOK",
    properties: [{
        key: "url",
        value: "https://example.com",
    }],
    authBasic: {
        user: "username",
        password: "password",
    },
});
// Create a notification channel to use in the workflow
const webhook_channel = new newrelic.NotificationChannel("webhook-channel", {
    type: "WEBHOOK",
    destinationId: webhook_destination.id,
    product: "IINT",
    properties: [{
        key: "payload",
        value: "{}",
        label: "Payload Template",
    }],
});
// A workflow that matches issues that include incidents triggered by the policy
const workflow_example = new newrelic.Workflow("workflow-example", {
    mutingRulesHandling: "NOTIFY_ALL_ISSUES",
    issuesFilter: {
        name: "Filter-name",
        type: "FILTER",
        predicates: [{
            attribute: "labels.policyIds",
            operator: "EXACTLY_MATCHES",
            values: [my_policy.id],
        }],
    },
    destinations: [{
        channelId: webhook_channel.id,
    }],
});

import pulumi
import pulumi_newrelic as newrelic

# Create a policy to track
my_policy = newrelic.AlertPolicy("my-policy")
# Create a reusable notification destination
webhook_destination = newrelic.NotificationDestination("webhook-destination",
    type="WEBHOOK",
    properties=[newrelic.NotificationDestinationPropertyArgs(
        key="url",
        value="https://example.com",
    )],
    auth_basic=newrelic.NotificationDestinationAuthBasicArgs(
        user="username",
        password="password",
    ))
# Create a notification channel to use in the workflow
webhook_channel = newrelic.NotificationChannel("webhook-channel",
    type="WEBHOOK",
    destination_id=webhook_destination.id,
    product="IINT",
    properties=[newrelic.NotificationChannelPropertyArgs(
        key="payload",
        value="{}",
        label="Payload Template",
    )])
# A workflow that matches issues that include incidents triggered by the policy
workflow_example = newrelic.Workflow("workflow-example",
    muting_rules_handling="NOTIFY_ALL_ISSUES",
    issues_filter=newrelic.WorkflowIssuesFilterArgs(
        name="Filter-name",
        type="FILTER",
        predicates=[newrelic.WorkflowIssuesFilterPredicateArgs(
            attribute="labels.policyIds",
            operator="EXACTLY_MATCHES",
            values=[my_policy.id],
        )],
    ),
    destinations=[newrelic.WorkflowDestinationArgs(
        channel_id=webhook_channel.id,
    )])

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

return await Deployment.RunAsync(() => 
{
    // Create a policy to track
    var my_policy = new NewRelic.AlertPolicy("my-policy");

    // Create a reusable notification destination
    var webhook_destination = new NewRelic.NotificationDestination("webhook-destination", new()
    {
        Type = "WEBHOOK",
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "url",
                Value = "https://example.com",
            },
        },
        AuthBasic = new NewRelic.Inputs.NotificationDestinationAuthBasicArgs
        {
            User = "username",
            Password = "password",
        },
    });

    // Create a notification channel to use in the workflow
    var webhook_channel = new NewRelic.NotificationChannel("webhook-channel", new()
    {
        Type = "WEBHOOK",
        DestinationId = webhook_destination.Id,
        Product = "IINT",
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationChannelPropertyArgs
            {
                Key = "payload",
                Value = "{}",
                Label = "Payload Template",
            },
        },
    });

    // A workflow that matches issues that include incidents triggered by the policy
    var workflow_example = new NewRelic.Workflow("workflow-example", new()
    {
        MutingRulesHandling = "NOTIFY_ALL_ISSUES",
        IssuesFilter = new NewRelic.Inputs.WorkflowIssuesFilterArgs
        {
            Name = "Filter-name",
            Type = "FILTER",
            Predicates = new[]
            {
                new NewRelic.Inputs.WorkflowIssuesFilterPredicateArgs
                {
                    Attribute = "labels.policyIds",
                    Operator = "EXACTLY_MATCHES",
                    Values = new[]
                    {
                        my_policy.Id,
                    },
                },
            },
        },
        Destinations = new[]
        {
            new NewRelic.Inputs.WorkflowDestinationArgs
            {
                ChannelId = webhook_channel.Id,
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewAlertPolicy(ctx, "my-policy", nil)
		if err != nil {
			return err
		}
		_, err = newrelic.NewNotificationDestination(ctx, "webhook-destination", &newrelic.NotificationDestinationArgs{
			Type: pulumi.String("WEBHOOK"),
			Properties: newrelic.NotificationDestinationPropertyArray{
				&newrelic.NotificationDestinationPropertyArgs{
					Key:   pulumi.String("url"),
					Value: pulumi.String("https://example.com"),
				},
			},
			AuthBasic: &newrelic.NotificationDestinationAuthBasicArgs{
				User:     pulumi.String("username"),
				Password: pulumi.String("password"),
			},
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewNotificationChannel(ctx, "webhook-channel", &newrelic.NotificationChannelArgs{
			Type:          pulumi.String("WEBHOOK"),
			DestinationId: webhook_destination.ID(),
			Product:       pulumi.String("IINT"),
			Properties: newrelic.NotificationChannelPropertyArray{
				&newrelic.NotificationChannelPropertyArgs{
					Key:   pulumi.String("payload"),
					Value: pulumi.String("{}"),
					Label: pulumi.String("Payload Template"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewWorkflow(ctx, "workflow-example", &newrelic.WorkflowArgs{
			MutingRulesHandling: pulumi.String("NOTIFY_ALL_ISSUES"),
			IssuesFilter: &newrelic.WorkflowIssuesFilterArgs{
				Name: pulumi.String("Filter-name"),
				Type: pulumi.String("FILTER"),
				Predicates: newrelic.WorkflowIssuesFilterPredicateArray{
					&newrelic.WorkflowIssuesFilterPredicateArgs{
						Attribute: pulumi.String("labels.policyIds"),
						Operator:  pulumi.String("EXACTLY_MATCHES"),
						Values: pulumi.StringArray{
							my_policy.ID(),
						},
					},
				},
			},
			Destinations: newrelic.WorkflowDestinationArray{
				&newrelic.WorkflowDestinationArgs{
					ChannelId: webhook_channel.ID(),
				},
			},
		})
		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.newrelic.AlertPolicy;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationAuthBasicArgs;
import com.pulumi.newrelic.NotificationChannel;
import com.pulumi.newrelic.NotificationChannelArgs;
import com.pulumi.newrelic.inputs.NotificationChannelPropertyArgs;
import com.pulumi.newrelic.Workflow;
import com.pulumi.newrelic.WorkflowArgs;
import com.pulumi.newrelic.inputs.WorkflowIssuesFilterArgs;
import com.pulumi.newrelic.inputs.WorkflowDestinationArgs;
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 my_policy = new AlertPolicy("my-policy");

        var webhook_destination = new NotificationDestination("webhook-destination", NotificationDestinationArgs.builder()        
            .type("WEBHOOK")
            .properties(NotificationDestinationPropertyArgs.builder()
                .key("url")
                .value("https://example.com")
                .build())
            .authBasic(NotificationDestinationAuthBasicArgs.builder()
                .user("username")
                .password("password")
                .build())
            .build());

        var webhook_channel = new NotificationChannel("webhook-channel", NotificationChannelArgs.builder()        
            .type("WEBHOOK")
            .destinationId(webhook_destination.id())
            .product("IINT")
            .properties(NotificationChannelPropertyArgs.builder()
                .key("payload")
                .value("{}")
                .label("Payload Template")
                .build())
            .build());

        var workflow_example = new Workflow("workflow-example", WorkflowArgs.builder()        
            .mutingRulesHandling("NOTIFY_ALL_ISSUES")
            .issuesFilter(WorkflowIssuesFilterArgs.builder()
                .name("Filter-name")
                .type("FILTER")
                .predicates(WorkflowIssuesFilterPredicateArgs.builder()
                    .attribute("labels.policyIds")
                    .operator("EXACTLY_MATCHES")
                    .values(my_policy.id())
                    .build())
                .build())
            .destinations(WorkflowDestinationArgs.builder()
                .channelId(webhook_channel.id())
                .build())
            .build());

    }
}

resources:
  # Create a policy to track
  my-policy:
    type: newrelic:AlertPolicy
  # Create a reusable notification destination
  webhook-destination:
    type: newrelic:NotificationDestination
    properties:
      type: WEBHOOK
      properties:
        - key: url
          value: https://example.com
      authBasic:
        user: username
        password: password
  # Create a notification channel to use in the workflow
  webhook-channel:
    type: newrelic:NotificationChannel
    properties:
      type: WEBHOOK
      destinationId: ${["webhook-destination"].id}
      product: IINT # Please note the product used!
      properties:
        - key: payload
          value: '{}'
          label: Payload Template
  # A workflow that matches issues that include incidents triggered by the policy
  workflow-example:
    type: newrelic:Workflow
    properties:
      mutingRulesHandling: NOTIFY_ALL_ISSUES
      issuesFilter:
        name: Filter-name
        type: FILTER
        predicates:
          - attribute: labels.policyIds
            operator: EXACTLY_MATCHES
            values:
              - ${["my-policy"].id}
      destinations:
        - channelId: ${["webhook-channel"].id}

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

const workflow_example = new newrelic.Workflow("workflow-example", {
    mutingRulesHandling: "NOTIFY_ALL_ISSUES",
    issuesFilter: {
        name: "Filter-name",
        type: "FILTER",
        predicates: [{
            attribute: "accumulations.tag.team",
            operator: "EXACTLY_MATCHES",
            values: ["my_team"],
        }],
    },
    enrichments: {
        nrqls: [{
            name: "Log Count",
            configurations: [{
                query: "SELECT count(*) FROM Log WHERE message like '%error%' since 10 minutes ago",
            }],
        }],
    },
    destinations: [{
        channelId: newrelic_notification_channel["webhook-channel"].id,
    }],
});

import pulumi
import pulumi_newrelic as newrelic

workflow_example = newrelic.Workflow("workflow-example",
    muting_rules_handling="NOTIFY_ALL_ISSUES",
    issues_filter=newrelic.WorkflowIssuesFilterArgs(
        name="Filter-name",
        type="FILTER",
        predicates=[newrelic.WorkflowIssuesFilterPredicateArgs(
            attribute="accumulations.tag.team",
            operator="EXACTLY_MATCHES",
            values=["my_team"],
        )],
    ),
    enrichments=newrelic.WorkflowEnrichmentsArgs(
        nrqls=[newrelic.WorkflowEnrichmentsNrqlArgs(
            name="Log Count",
            configurations=[newrelic.WorkflowEnrichmentsNrqlConfigurationArgs(
                query="SELECT count(*) FROM Log WHERE message like '%error%' since 10 minutes ago",
            )],
        )],
    ),
    destinations=[newrelic.WorkflowDestinationArgs(
        channel_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
    )])

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

return await Deployment.RunAsync(() => 
{
    var workflow_example = new NewRelic.Workflow("workflow-example", new()
    {
        MutingRulesHandling = "NOTIFY_ALL_ISSUES",
        IssuesFilter = new NewRelic.Inputs.WorkflowIssuesFilterArgs
        {
            Name = "Filter-name",
            Type = "FILTER",
            Predicates = new[]
            {
                new NewRelic.Inputs.WorkflowIssuesFilterPredicateArgs
                {
                    Attribute = "accumulations.tag.team",
                    Operator = "EXACTLY_MATCHES",
                    Values = new[]
                    {
                        "my_team",
                    },
                },
            },
        },
        Enrichments = new NewRelic.Inputs.WorkflowEnrichmentsArgs
        {
            Nrqls = new[]
            {
                new NewRelic.Inputs.WorkflowEnrichmentsNrqlArgs
                {
                    Name = "Log Count",
                    Configurations = new[]
                    {
                        new NewRelic.Inputs.WorkflowEnrichmentsNrqlConfigurationArgs
                        {
                            Query = "SELECT count(*) FROM Log WHERE message like '%error%' since 10 minutes ago",
                        },
                    },
                },
            },
        },
        Destinations = new[]
        {
            new NewRelic.Inputs.WorkflowDestinationArgs
            {
                ChannelId = newrelic_notification_channel.Webhook_channel.Id,
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewWorkflow(ctx, "workflow-example", &newrelic.WorkflowArgs{
			MutingRulesHandling: pulumi.String("NOTIFY_ALL_ISSUES"),
			IssuesFilter: &newrelic.WorkflowIssuesFilterArgs{
				Name: pulumi.String("Filter-name"),
				Type: pulumi.String("FILTER"),
				Predicates: newrelic.WorkflowIssuesFilterPredicateArray{
					&newrelic.WorkflowIssuesFilterPredicateArgs{
						Attribute: pulumi.String("accumulations.tag.team"),
						Operator:  pulumi.String("EXACTLY_MATCHES"),
						Values: pulumi.StringArray{
							pulumi.String("my_team"),
						},
					},
				},
			},
			Enrichments: &newrelic.WorkflowEnrichmentsArgs{
				Nrqls: newrelic.WorkflowEnrichmentsNrqlArray{
					&newrelic.WorkflowEnrichmentsNrqlArgs{
						Name: pulumi.String("Log Count"),
						Configurations: newrelic.WorkflowEnrichmentsNrqlConfigurationArray{
							&newrelic.WorkflowEnrichmentsNrqlConfigurationArgs{
								Query: pulumi.String("SELECT count(*) FROM Log WHERE message like '%error%' since 10 minutes ago"),
							},
						},
					},
				},
			},
			Destinations: newrelic.WorkflowDestinationArray{
				&newrelic.WorkflowDestinationArgs{
					ChannelId: pulumi.Any(newrelic_notification_channel.WebhookChannel.Id),
				},
			},
		})
		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.newrelic.Workflow;
import com.pulumi.newrelic.WorkflowArgs;
import com.pulumi.newrelic.inputs.WorkflowIssuesFilterArgs;
import com.pulumi.newrelic.inputs.WorkflowEnrichmentsArgs;
import com.pulumi.newrelic.inputs.WorkflowDestinationArgs;
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 workflow_example = new Workflow("workflow-example", WorkflowArgs.builder()        
            .mutingRulesHandling("NOTIFY_ALL_ISSUES")
            .issuesFilter(WorkflowIssuesFilterArgs.builder()
                .name("Filter-name")
                .type("FILTER")
                .predicates(WorkflowIssuesFilterPredicateArgs.builder()
                    .attribute("accumulations.tag.team")
                    .operator("EXACTLY_MATCHES")
                    .values("my_team")
                    .build())
                .build())
            .enrichments(WorkflowEnrichmentsArgs.builder()
                .nrqls(WorkflowEnrichmentsNrqlArgs.builder()
                    .name("Log Count")
                    .configurations(WorkflowEnrichmentsNrqlConfigurationArgs.builder()
                        .query("SELECT count(*) FROM Log WHERE message like '%error%' since 10 minutes ago")
                        .build())
                    .build())
                .build())
            .destinations(WorkflowDestinationArgs.builder()
                .channelId(newrelic_notification_channel.webhook-channel().id())
                .build())
            .build());

    }
}

resources:
  workflow-example:
    type: newrelic:Workflow
    properties:
      mutingRulesHandling: NOTIFY_ALL_ISSUES
      issuesFilter:
        name: Filter-name
        type: FILTER
        predicates:
          - attribute: accumulations.tag.team
            operator: EXACTLY_MATCHES
            values:
              - my_team
      enrichments:
        nrqls:
          - name: Log Count
            configurations:
              - query: SELECT count(*) FROM Log WHERE message like '%error%' since 10 minutes ago
      destinations:
        - channelId: ${newrelic_notification_channel"webhook-channel"[%!s(MISSING)].id}

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

const workflow_example = new newrelic.Workflow("workflow-example", {
    mutingRulesHandling: "NOTIFY_ALL_ISSUES",
    issuesFilter: {
        name: "Filter-name",
        type: "FILTER",
        predicates: [{
            attribute: "accumulations.tag.team",
            operator: "EXACTLY_MATCHES",
            values: ["my_team"],
        }],
    },
    destinations: [{
        channelId: newrelic_notification_channel["webhook-channel"].id,
        notificationTriggers: ["ACTIVATED"],
    }],
});

import pulumi
import pulumi_newrelic as newrelic

workflow_example = newrelic.Workflow("workflow-example",
    muting_rules_handling="NOTIFY_ALL_ISSUES",
    issues_filter=newrelic.WorkflowIssuesFilterArgs(
        name="Filter-name",
        type="FILTER",
        predicates=[newrelic.WorkflowIssuesFilterPredicateArgs(
            attribute="accumulations.tag.team",
            operator="EXACTLY_MATCHES",
            values=["my_team"],
        )],
    ),
    destinations=[newrelic.WorkflowDestinationArgs(
        channel_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        notification_triggers=["ACTIVATED"],
    )])

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

return await Deployment.RunAsync(() => 
{
    var workflow_example = new NewRelic.Workflow("workflow-example", new()
    {
        MutingRulesHandling = "NOTIFY_ALL_ISSUES",
        IssuesFilter = new NewRelic.Inputs.WorkflowIssuesFilterArgs
        {
            Name = "Filter-name",
            Type = "FILTER",
            Predicates = new[]
            {
                new NewRelic.Inputs.WorkflowIssuesFilterPredicateArgs
                {
                    Attribute = "accumulations.tag.team",
                    Operator = "EXACTLY_MATCHES",
                    Values = new[]
                    {
                        "my_team",
                    },
                },
            },
        },
        Destinations = new[]
        {
            new NewRelic.Inputs.WorkflowDestinationArgs
            {
                ChannelId = newrelic_notification_channel.Webhook_channel.Id,
                NotificationTriggers = new[]
                {
                    "ACTIVATED",
                },
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewWorkflow(ctx, "workflow-example", &newrelic.WorkflowArgs{
			MutingRulesHandling: pulumi.String("NOTIFY_ALL_ISSUES"),
			IssuesFilter: &newrelic.WorkflowIssuesFilterArgs{
				Name: pulumi.String("Filter-name"),
				Type: pulumi.String("FILTER"),
				Predicates: newrelic.WorkflowIssuesFilterPredicateArray{
					&newrelic.WorkflowIssuesFilterPredicateArgs{
						Attribute: pulumi.String("accumulations.tag.team"),
						Operator:  pulumi.String("EXACTLY_MATCHES"),
						Values: pulumi.StringArray{
							pulumi.String("my_team"),
						},
					},
				},
			},
			Destinations: newrelic.WorkflowDestinationArray{
				&newrelic.WorkflowDestinationArgs{
					ChannelId: pulumi.Any(newrelic_notification_channel.WebhookChannel.Id),
					NotificationTriggers: pulumi.StringArray{
						pulumi.String("ACTIVATED"),
					},
				},
			},
		})
		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.newrelic.Workflow;
import com.pulumi.newrelic.WorkflowArgs;
import com.pulumi.newrelic.inputs.WorkflowIssuesFilterArgs;
import com.pulumi.newrelic.inputs.WorkflowDestinationArgs;
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 workflow_example = new Workflow("workflow-example", WorkflowArgs.builder()        
            .mutingRulesHandling("NOTIFY_ALL_ISSUES")
            .issuesFilter(WorkflowIssuesFilterArgs.builder()
                .name("Filter-name")
                .type("FILTER")
                .predicates(WorkflowIssuesFilterPredicateArgs.builder()
                    .attribute("accumulations.tag.team")
                    .operator("EXACTLY_MATCHES")
                    .values("my_team")
                    .build())
                .build())
            .destinations(WorkflowDestinationArgs.builder()
                .channelId(newrelic_notification_channel.webhook-channel().id())
                .notificationTriggers("ACTIVATED")
                .build())
            .build());

    }
}

resources:
  workflow-example:
    type: newrelic:Workflow
    properties:
      mutingRulesHandling: NOTIFY_ALL_ISSUES
      issuesFilter:
        name: Filter-name
        type: FILTER
        predicates:
          - attribute: accumulations.tag.team
            operator: EXACTLY_MATCHES
            values:
              - my_team
      destinations:
        - channelId: ${newrelic_notification_channel"webhook-channel"[%!s(MISSING)].id}
          notificationTriggers:
            - ACTIVATED