logfire.getPagerdutyService

import * as pulumi from "@pulumi/pulumi";
import * as logfire from "@pydantic/pulumi-logfire";

const onCall = logfire.getPagerdutyService({
    accountSubdomain: "acme",
    region: "us",
    pagerdutyServiceId: "PABC123",
});
const pagerdutyApp = new logfire.Channel("pagerdutyApp", {config: [{
    type: "pagerduty-integration",
    installId: onCall.then(onCall => onCall.installId),
    serviceId: onCall.then(onCall => onCall.serviceId),
}]});

import pulumi
import pulumi_logfire as logfire

on_call = logfire.get_pagerduty_service(account_subdomain="acme",
    region="us",
    pagerduty_service_id="PABC123")
pagerduty_app = logfire.Channel("pagerdutyApp", config=[{
    "type": "pagerduty-integration",
    "installId": on_call.install_id,
    "serviceId": on_call.service_id,
}])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		onCall, err := logfire.GetPagerdutyService(ctx, &logfire.GetPagerdutyServiceArgs{
			AccountSubdomain:   "acme",
			Region:             pulumi.StringRef("us"),
			PagerdutyServiceId: "PABC123",
		}, nil)
		if err != nil {
			return err
		}
		_, err = logfire.NewChannel(ctx, "pagerdutyApp", &logfire.ChannelArgs{
			Config: logfire.ChannelConfigArgs{
				map[string]interface{}{
					"type":      "pagerduty-integration",
					"installId": onCall.InstallId,
					"serviceId": onCall.ServiceId,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var onCall = Logfire.GetPagerdutyService.Invoke(new()
    {
        AccountSubdomain = "acme",
        Region = "us",
        PagerdutyServiceId = "PABC123",
    });

    var pagerdutyApp = new Logfire.Channel("pagerdutyApp", new()
    {
        Config = new[]
        {
            
            {
                { "type", "pagerduty-integration" },
                { "installId", onCall.Apply(getPagerdutyServiceResult => getPagerdutyServiceResult.InstallId) },
                { "serviceId", onCall.Apply(getPagerdutyServiceResult => getPagerdutyServiceResult.ServiceId) },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.logfire.LogfireFunctions;
import com.pulumi.logfire.inputs.GetPagerdutyServiceArgs;
import com.pulumi.logfire.Channel;
import com.pulumi.logfire.ChannelArgs;
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 onCall = LogfireFunctions.getPagerdutyService(GetPagerdutyServiceArgs.builder()
            .accountSubdomain("acme")
            .region("us")
            .pagerdutyServiceId("PABC123")
            .build());

        var pagerdutyApp = new Channel("pagerdutyApp", ChannelArgs.builder()
            .config(ChannelConfigArgs.builder()
                .type("pagerduty-integration")
                .installId(onCall.installId())
                .serviceId(onCall.serviceId())
                .build())
            .build());

    }
}

resources:
  pagerdutyApp:
    type: logfire:Channel
    properties:
      config:
        - type: pagerduty-integration
          installId: ${onCall.installId}
          serviceId: ${onCall.serviceId}
variables:
  onCall:
    fn::invoke:
      function: logfire:getPagerdutyService
      arguments:
        accountSubdomain: acme
        region: us
        pagerdutyServiceId: PABC123

function getPagerdutyService(args: GetPagerdutyServiceArgs, opts?: InvokeOptions): Promise<GetPagerdutyServiceResult>
function getPagerdutyServiceOutput(args: GetPagerdutyServiceOutputArgs, opts?: InvokeOutputOptions): Output<GetPagerdutyServiceResult>

def get_pagerduty_service(account_subdomain: Optional[str] = None,
                          pagerduty_service_id: Optional[str] = None,
                          region: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetPagerdutyServiceResult
def get_pagerduty_service_output(account_subdomain: pulumi.Input[Optional[str]] = None,
                          pagerduty_service_id: pulumi.Input[Optional[str]] = None,
                          region: pulumi.Input[Optional[str]] = None,
                          opts: Optional[InvokeOutputOptions] = None) -> Output[GetPagerdutyServiceResult]

func GetPagerdutyService(ctx *Context, args *GetPagerdutyServiceArgs, opts ...InvokeOption) (*GetPagerdutyServiceResult, error)
func GetPagerdutyServiceOutput(ctx *Context, args *GetPagerdutyServiceOutputArgs, opts ...InvokeOption) GetPagerdutyServiceResultOutput

public static class GetPagerdutyService 
{
    public static Task<GetPagerdutyServiceResult> InvokeAsync(GetPagerdutyServiceArgs args, InvokeOptions? opts = null)
    public static Output<GetPagerdutyServiceResult> Invoke(GetPagerdutyServiceInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetPagerdutyServiceResult> Invoke(GetPagerdutyServiceInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetPagerdutyServiceResult> getPagerdutyService(GetPagerdutyServiceArgs args, InvokeOptions options)
public static Output<GetPagerdutyServiceResult> getPagerdutyService(GetPagerdutyServiceArgs args, InvokeOptions options)
public static Output<GetPagerdutyServiceResult> getPagerdutyService(GetPagerdutyServiceArgs args, InvokeOutputOptions options)

fn::invoke:
  function: logfire:index/getPagerdutyService:getPagerdutyService
  arguments:
    # arguments dictionary

data "logfire_get_pagerduty_service" "name" {
    # arguments
}