honeycombio.getRecipient

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

// search for a Slack recipient with channel name "honeycomb-triggers"
const slack = honeycombio.getRecipient({
    type: "slack",
    detailFilter: {
        name: "channel",
        value: "#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

# search for a Slack recipient with channel name "honeycomb-triggers"
slack = honeycombio.get_recipient(type="slack",
    detail_filter={
        "name": "channel",
        "value": "#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"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// search for a Slack recipient with channel name "honeycomb-triggers"
		slack, err := honeycombio.GetRecipient(ctx, &honeycombio.GetRecipientArgs{
			Type: "slack",
			DetailFilter: honeycombio.GetRecipientDetailFilter{
				Name:  "channel",
				Value: 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.Any(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(() => 
{
    // search for a Slack recipient with channel name "honeycomb-triggers"
    var slack = Honeycombio.GetRecipient.Invoke(new()
    {
        Type = "slack",
        DetailFilter = new Honeycombio.Inputs.GetRecipientDetailFilterInputArgs
        {
            Name = "channel",
            Value = "#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(getRecipientResult => getRecipientResult.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.GetRecipientArgs;
import com.pulumi.honeycombio.inputs.GetRecipientDetailFilterArgs;
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) {
        // search for a Slack recipient with channel name "honeycomb-triggers"
        final var slack = HoneycombioFunctions.getRecipient(GetRecipientArgs.builder()
            .type("slack")
            .detailFilter(GetRecipientDetailFilterArgs.builder()
                .name("channel")
                .value("#honeycomb-triggers")
                .build())
            .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());

    }
}

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 Slack recipient with channel name "honeycomb-triggers"
  slack:
    fn::invoke:
      function: honeycombio:getRecipient
      arguments:
        type: slack
        detailFilter:
          name: channel
          value: '#honeycomb-triggers'
  example:
    fn::invoke:
      function: honeycombio:getQuerySpecification
      arguments:
        calculations:
          - op: AVG
            column: duration_ms

function getRecipient(args: GetRecipientArgs, opts?: InvokeOptions): Promise<GetRecipientResult>
function getRecipientOutput(args: GetRecipientOutputArgs, opts?: InvokeOptions): Output<GetRecipientResult>

def get_recipient(dataset: Optional[str] = None,
                  detail_filter: Optional[GetRecipientDetailFilter] = None,
                  id: Optional[str] = None,
                  target: Optional[str] = None,
                  type: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetRecipientResult
def get_recipient_output(dataset: Optional[pulumi.Input[str]] = None,
                  detail_filter: Optional[pulumi.Input[GetRecipientDetailFilterArgs]] = None,
                  id: Optional[pulumi.Input[str]] = None,
                  target: Optional[pulumi.Input[str]] = None,
                  type: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetRecipientResult]

func GetRecipient(ctx *Context, args *GetRecipientArgs, opts ...InvokeOption) (*GetRecipientResult, error)
func GetRecipientOutput(ctx *Context, args *GetRecipientOutputArgs, opts ...InvokeOption) GetRecipientResultOutput

public static class GetRecipient 
{
    public static Task<GetRecipientResult> InvokeAsync(GetRecipientArgs args, InvokeOptions? opts = null)
    public static Output<GetRecipientResult> Invoke(GetRecipientInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRecipientResult> getRecipient(GetRecipientArgs args, InvokeOptions options)
public static Output<GetRecipientResult> getRecipient(GetRecipientArgs args, InvokeOptions options)

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