newrelic.EntityTags

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

const foo = newrelic.getEntity({
    name: "Example application",
    type: "APPLICATION",
    domain: "APM",
});
const fooEntityTags = new newrelic.EntityTags("foo", {
    guid: foo.then(foo => foo.guid),
    tags: [
        {
            key: "my-key",
            values: [
                "my-value",
                "my-other-value",
            ],
        },
        {
            key: "my-key-2",
            values: ["my-value-2"],
        },
    ],
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.get_entity(name="Example application",
    type="APPLICATION",
    domain="APM")
foo_entity_tags = newrelic.EntityTags("foo",
    guid=foo.guid,
    tags=[
        {
            "key": "my-key",
            "values": [
                "my-value",
                "my-other-value",
            ],
        },
        {
            "key": "my-key-2",
            "values": ["my-value-2"],
        },
    ])

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 {
		foo, err := newrelic.GetEntity(ctx, &newrelic.GetEntityArgs{
			Name:   "Example application",
			Type:   pulumi.StringRef("APPLICATION"),
			Domain: pulumi.StringRef("APM"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = newrelic.NewEntityTags(ctx, "foo", &newrelic.EntityTagsArgs{
			Guid: pulumi.String(foo.Guid),
			Tags: newrelic.EntityTagsTagArray{
				&newrelic.EntityTagsTagArgs{
					Key: pulumi.String("my-key"),
					Values: pulumi.StringArray{
						pulumi.String("my-value"),
						pulumi.String("my-other-value"),
					},
				},
				&newrelic.EntityTagsTagArgs{
					Key: pulumi.String("my-key-2"),
					Values: pulumi.StringArray{
						pulumi.String("my-value-2"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var foo = NewRelic.GetEntity.Invoke(new()
    {
        Name = "Example application",
        Type = "APPLICATION",
        Domain = "APM",
    });

    var fooEntityTags = new NewRelic.EntityTags("foo", new()
    {
        Guid = foo.Apply(getEntityResult => getEntityResult.Guid),
        Tags = new[]
        {
            new NewRelic.Inputs.EntityTagsTagArgs
            {
                Key = "my-key",
                Values = new[]
                {
                    "my-value",
                    "my-other-value",
                },
            },
            new NewRelic.Inputs.EntityTagsTagArgs
            {
                Key = "my-key-2",
                Values = new[]
                {
                    "my-value-2",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NewrelicFunctions;
import com.pulumi.newrelic.inputs.GetEntityArgs;
import com.pulumi.newrelic.EntityTags;
import com.pulumi.newrelic.EntityTagsArgs;
import com.pulumi.newrelic.inputs.EntityTagsTagArgs;
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 foo = NewrelicFunctions.getEntity(GetEntityArgs.builder()
            .name("Example application")
            .type("APPLICATION")
            .domain("APM")
            .build());

        var fooEntityTags = new EntityTags("fooEntityTags", EntityTagsArgs.builder()
            .guid(foo.applyValue(getEntityResult -> getEntityResult.guid()))
            .tags(            
                EntityTagsTagArgs.builder()
                    .key("my-key")
                    .values(                    
                        "my-value",
                        "my-other-value")
                    .build(),
                EntityTagsTagArgs.builder()
                    .key("my-key-2")
                    .values("my-value-2")
                    .build())
            .build());

    }
}

resources:
  fooEntityTags:
    type: newrelic:EntityTags
    name: foo
    properties:
      guid: ${foo.guid}
      tags:
        - key: my-key
          values:
            - my-value
            - my-other-value
        - key: my-key-2
          values:
            - my-value-2
variables:
  foo:
    fn::invoke:
      Function: newrelic:getEntity
      Arguments:
        name: Example application
        type: APPLICATION
        domain: APM

var entityTagsResource = new NewRelic.EntityTags("entityTagsResource", new()
{
    Guid = "string",
    Tags = new[]
    {
        new NewRelic.Inputs.EntityTagsTagArgs
        {
            Key = "string",
            Values = new[]
            {
                "string",
            },
        },
    },
});

example, err := newrelic.NewEntityTags(ctx, "entityTagsResource", &newrelic.EntityTagsArgs{
	Guid: pulumi.String("string"),
	Tags: newrelic.EntityTagsTagArray{
		&newrelic.EntityTagsTagArgs{
			Key: pulumi.String("string"),
			Values: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
})

var entityTagsResource = new EntityTags("entityTagsResource", EntityTagsArgs.builder()
    .guid("string")
    .tags(EntityTagsTagArgs.builder()
        .key("string")
        .values("string")
        .build())
    .build());

entity_tags_resource = newrelic.EntityTags("entityTagsResource",
    guid="string",
    tags=[newrelic.EntityTagsTagArgs(
        key="string",
        values=["string"],
    )])

const entityTagsResource = new newrelic.EntityTags("entityTagsResource", {
    guid: "string",
    tags: [{
        key: "string",
        values: ["string"],
    }],
});

type: newrelic:EntityTags
properties:
    guid: string
    tags:
        - key: string
          values:
            - string