honeycombio.getTriggerRecipient

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

const config = new pulumi.Config();
const dataset = config.require("dataset");
// search for a trigger recipient of type "slack" and target "honeycomb-triggers" in the given dataset
const slack = honeycombio.getTriggerRecipient({
    dataset: dataset,
    type: "slack",
    target: "honeycomb-triggers",
});
const example = honeycombio.getQuerySpecification({
    calculations: [{
        op: "AVG",
        column: "duration_ms",
    }],
});
const exampleTrigger = new honeycombio.Trigger("example", {
    name: "Requests are slower than usual",
    queryJson: example.then(example => example.json),
    dataset: dataset,
    thresholds: [{
        op: ">",
        value: 1000,
    }],
    recipients: [
        {
            type: "email",
            target: "hello@example.com",
        },
        {
            id: slack.then(slack => slack.id),
        },
    ],
});

import pulumi
import pulumi_honeycombio as honeycombio

config = pulumi.Config()
dataset = config.require("dataset")
# search for a trigger recipient of type "slack" and target "honeycomb-triggers" in the given dataset
slack = honeycombio.get_trigger_recipient(dataset=dataset,
    type="slack",
    target="honeycomb-triggers")
example = honeycombio.get_query_specification(calculations=[{
    "op": "AVG",
    "column": "duration_ms",
}])
example_trigger = honeycombio.Trigger("example",
    name="Requests are slower than usual",
    query_json=example.json,
    dataset=dataset,
    thresholds=[{
        "op": ">",
        "value": 1000,
    }],
    recipients=[
        {
            "type": "email",
            "target": "hello@example.com",
        },
        {
            "id": slack.id,
        },
    ])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/honeycombio/honeycombio"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		dataset := cfg.Require("dataset")
		// search for a trigger recipient of type "slack" and target "honeycomb-triggers" in the given dataset
		slack, err := honeycombio.GetTriggerRecipient(ctx, &honeycombio.GetTriggerRecipientArgs{
			Dataset: dataset,
			Type:    "slack",
			Target:  pulumi.StringRef("honeycomb-triggers"),
		}, nil)
		if err != nil {
			return err
		}
		example, err := honeycombio.GetQuerySpecification(ctx, &honeycombio.GetQuerySpecificationArgs{
			Calculations: []honeycombio.GetQuerySpecificationCalculation{
				{
					Op:     "AVG",
					Column: pulumi.StringRef("duration_ms"),
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = honeycombio.NewTrigger(ctx, "example", &honeycombio.TriggerArgs{
			Name:      pulumi.String("Requests are slower than usual"),
			QueryJson: pulumi.String(example.Json),
			Dataset:   pulumi.String(dataset),
			Thresholds: honeycombio.TriggerThresholdArray{
				&honeycombio.TriggerThresholdArgs{
					Op:    pulumi.String(">"),
					Value: pulumi.Float64(1000),
				},
			},
			Recipients: honeycombio.TriggerRecipientArray{
				&honeycombio.TriggerRecipientArgs{
					Type:   pulumi.String("email"),
					Target: pulumi.String("hello@example.com"),
				},
				&honeycombio.TriggerRecipientArgs{
					Id: pulumi.String(slack.Id),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var dataset = config.Require("dataset");
    // search for a trigger recipient of type "slack" and target "honeycomb-triggers" in the given dataset
    var slack = Honeycombio.GetTriggerRecipient.Invoke(new()
    {
        Dataset = dataset,
        Type = "slack",
        Target = "honeycomb-triggers",
    });

    var example = Honeycombio.GetQuerySpecification.Invoke(new()
    {
        Calculations = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationCalculationInputArgs
            {
                Op = "AVG",
                Column = "duration_ms",
            },
        },
    });

    var exampleTrigger = new Honeycombio.Trigger("example", new()
    {
        Name = "Requests are slower than usual",
        QueryJson = example.Apply(getQuerySpecificationResult => getQuerySpecificationResult.Json),
        Dataset = dataset,
        Thresholds = new[]
        {
            new Honeycombio.Inputs.TriggerThresholdArgs
            {
                Op = ">",
                Value = 1000,
            },
        },
        Recipients = new[]
        {
            new Honeycombio.Inputs.TriggerRecipientArgs
            {
                Type = "email",
                Target = "hello@example.com",
            },
            new Honeycombio.Inputs.TriggerRecipientArgs
            {
                Id = slack.Apply(getTriggerRecipientResult => getTriggerRecipientResult.Id),
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.honeycombio.HoneycombioFunctions;
import com.pulumi.honeycombio.inputs.GetTriggerRecipientArgs;
import com.pulumi.honeycombio.inputs.GetQuerySpecificationArgs;
import com.pulumi.honeycombio.Trigger;
import com.pulumi.honeycombio.TriggerArgs;
import com.pulumi.honeycombio.inputs.TriggerThresholdArgs;
import com.pulumi.honeycombio.inputs.TriggerRecipientArgs;
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) {
        final var config = ctx.config();
        final var dataset = config.get("dataset");
        // search for a trigger recipient of type "slack" and target "honeycomb-triggers" in the given dataset
        final var slack = HoneycombioFunctions.getTriggerRecipient(GetTriggerRecipientArgs.builder()
            .dataset(dataset)
            .type("slack")
            .target("honeycomb-triggers")
            .build());

        final var example = HoneycombioFunctions.getQuerySpecification(GetQuerySpecificationArgs.builder()
            .calculations(GetQuerySpecificationCalculationArgs.builder()
                .op("AVG")
                .column("duration_ms")
                .build())
            .build());

        var exampleTrigger = new Trigger("exampleTrigger", TriggerArgs.builder()
            .name("Requests are slower than usual")
            .queryJson(example.json())
            .dataset(dataset)
            .thresholds(TriggerThresholdArgs.builder()
                .op(">")
                .value(1000.0)
                .build())
            .recipients(            
                TriggerRecipientArgs.builder()
                    .type("email")
                    .target("hello@example.com")
                    .build(),
                TriggerRecipientArgs.builder()
                    .id(slack.id())
                    .build())
            .build());

    }
}

configuration:
  dataset:
    type: string
resources:
  exampleTrigger:
    type: honeycombio:Trigger
    name: example
    properties:
      name: Requests are slower than usual
      queryJson: ${example.json}
      dataset: ${dataset}
      thresholds:
        - op: '>'
          value: 1000
      recipients:
        - type: email
          target: hello@example.com
        - id: ${slack.id}
variables:
  # search for a trigger recipient of type "slack" and target "honeycomb-triggers" in the given dataset
  slack:
    fn::invoke:
      function: honeycombio:getTriggerRecipient
      arguments:
        dataset: ${dataset}
        type: slack
        target: honeycomb-triggers
  example:
    fn::invoke:
      function: honeycombio:getQuerySpecification
      arguments:
        calculations:
          - op: AVG
            column: duration_ms

function getTriggerRecipient(args: GetTriggerRecipientArgs, opts?: InvokeOptions): Promise<GetTriggerRecipientResult>
function getTriggerRecipientOutput(args: GetTriggerRecipientOutputArgs, opts?: InvokeOptions): Output<GetTriggerRecipientResult>

def get_trigger_recipient(dataset: Optional[str] = None,
                          id: Optional[str] = None,
                          target: Optional[str] = None,
                          type: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetTriggerRecipientResult
def get_trigger_recipient_output(dataset: Optional[pulumi.Input[str]] = None,
                          id: Optional[pulumi.Input[str]] = None,
                          target: Optional[pulumi.Input[str]] = None,
                          type: Optional[pulumi.Input[str]] = None,
                          opts: Optional[InvokeOptions] = None) -> Output[GetTriggerRecipientResult]

func GetTriggerRecipient(ctx *Context, args *GetTriggerRecipientArgs, opts ...InvokeOption) (*GetTriggerRecipientResult, error)
func GetTriggerRecipientOutput(ctx *Context, args *GetTriggerRecipientOutputArgs, opts ...InvokeOption) GetTriggerRecipientResultOutput

public static class GetTriggerRecipient 
{
    public static Task<GetTriggerRecipientResult> InvokeAsync(GetTriggerRecipientArgs args, InvokeOptions? opts = null)
    public static Output<GetTriggerRecipientResult> Invoke(GetTriggerRecipientInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTriggerRecipientResult> getTriggerRecipient(GetTriggerRecipientArgs args, InvokeOptions options)
public static Output<GetTriggerRecipientResult> getTriggerRecipient(GetTriggerRecipientArgs args, InvokeOptions options)

fn::invoke:
  function: honeycombio:index/getTriggerRecipient:getTriggerRecipient
  arguments:
    # arguments dictionary