Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Newrelic Provider
  4. API Docs
  5. plugins
  6. Workload
Viewing docs for New Relic v5.73.0
published on Wednesday, Jul 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-newrelic

newrelic.plugins.Workload

newrelic logo
Viewing docs for New Relic v5.73.0
published on Wednesday, Jul 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-newrelic

    Use this resource to create, update, and delete a New Relic One workload.

    Workloads let you group related entities — services, hosts, databases, browser apps, and more — into a single operational view to monitor health and triage incidents across a business domain.

    This resource supports two workload modes:

    • Standard workload — define membership using entity GUIDs (entityGuids) and/or dynamic search queries (entitySearchQuery). Membership updates automatically as query results change. Cannot be used together with dynamicFlows.
    • Intelligent workload — use dynamicFlows to anchor the workload to a transaction entry point. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. New Relic auto-discovers and refreshes related entities every five minutes using Transaction 360 distributed tracing data. Supports statusConfigAlertPolicy in addition to the standard statusConfigAutomatic and statusConfigStatic options.

    A New Relic User API key is required to provision this resource. Set the apiKey attribute in the provider block or the NEW_RELIC_API_KEY environment variable with your User API key.

    Example Usage

    Standard Workload

    Include entities with a certain string on the name.

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

const foo = new newrelic.plugins.Workload("foo", {
    name: "Example workload",
    accountId: "12345678",
    entityGuids: ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entitySearchQueries: [{
        query: "name like '%Example application%'",
    }],
    scopeAccountIds: ["12345678"],
});

    import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.plugins.Workload("foo",
    name="Example workload",
    account_id="12345678",
    entity_guids=["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entity_search_queries=[{
        "query": "name like '%Example application%'",
    }],
    scope_account_ids=["12345678"])

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := plugins.NewWorkload(ctx, "foo", &plugins.WorkloadArgs{
			Name:      pulumi.String("Example workload"),
			AccountId: pulumi.String("12345678"),
			EntityGuids: pulumi.StringArray{
				pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
			},
			EntitySearchQueries: plugins.WorkloadEntitySearchQueryArray{
				&plugins.WorkloadEntitySearchQueryArgs{
					Query: pulumi.String("name like '%Example application%'"),
				},
			},
			ScopeAccountIds: pulumi.StringArray{
				pulumi.String("12345678"),
			},
		})
		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 = new NewRelic.Plugins.Workload("foo", new()
    {
        Name = "Example workload",
        AccountId = "12345678",
        EntityGuids = new[]
        {
            "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        },
        EntitySearchQueries = new[]
        {
            new NewRelic.Plugins.Inputs.WorkloadEntitySearchQueryArgs
            {
                Query = "name like '%Example application%'",
            },
        },
        ScopeAccountIds = new[]
        {
            "12345678",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.plugins.Workload;
import com.pulumi.newrelic.plugins.WorkloadArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadEntitySearchQueryArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 foo = new Workload("foo", WorkloadArgs.builder()
            .name("Example workload")
            .accountId("12345678")
            .entityGuids("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1")
            .entitySearchQueries(WorkloadEntitySearchQueryArgs.builder()
                .query("name like '%Example application%'")
                .build())
            .scopeAccountIds("12345678")
            .build());

    }
}

    resources:
  foo:
    type: newrelic:plugins:Workload
    properties:
      name: Example workload
      accountId: 1.2345678e+07
      entityGuids:
        - MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
      entitySearchQueries:
        - query: name like '%Example application%'
      scopeAccountIds:
        - 1.2345678e+07

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_plugins_workload" "foo" {
  name         = "Example workload"
  account_id   = 12345678
  entity_guids = ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"]
  entity_search_queries {
    query = "name like '%Example application%'"
  }
  scope_account_ids = [12345678]
}

    Include entities with a set of tags.

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

const foo = new newrelic.plugins.Workload("foo", {
    name: "Example workload with tags",
    accountId: "12345678",
    entityGuids: ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entitySearchQueries: [{
        query: "tags.accountId = '12345678' AND tags.environment='production' AND tags.language='java'",
    }],
    scopeAccountIds: ["12345678"],
});

    import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.plugins.Workload("foo",
    name="Example workload with tags",
    account_id="12345678",
    entity_guids=["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entity_search_queries=[{
        "query": "tags.accountId = '12345678' AND tags.environment='production' AND tags.language='java'",
    }],
    scope_account_ids=["12345678"])

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := plugins.NewWorkload(ctx, "foo", &plugins.WorkloadArgs{
			Name:      pulumi.String("Example workload with tags"),
			AccountId: pulumi.String("12345678"),
			EntityGuids: pulumi.StringArray{
				pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
			},
			EntitySearchQueries: plugins.WorkloadEntitySearchQueryArray{
				&plugins.WorkloadEntitySearchQueryArgs{
					Query: pulumi.String("tags.accountId = '12345678' AND tags.environment='production' AND tags.language='java'"),
				},
			},
			ScopeAccountIds: pulumi.StringArray{
				pulumi.String("12345678"),
			},
		})
		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 = new NewRelic.Plugins.Workload("foo", new()
    {
        Name = "Example workload with tags",
        AccountId = "12345678",
        EntityGuids = new[]
        {
            "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        },
        EntitySearchQueries = new[]
        {
            new NewRelic.Plugins.Inputs.WorkloadEntitySearchQueryArgs
            {
                Query = "tags.accountId = '12345678' AND tags.environment='production' AND tags.language='java'",
            },
        },
        ScopeAccountIds = new[]
        {
            "12345678",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.plugins.Workload;
import com.pulumi.newrelic.plugins.WorkloadArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadEntitySearchQueryArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 foo = new Workload("foo", WorkloadArgs.builder()
            .name("Example workload with tags")
            .accountId("12345678")
            .entityGuids("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1")
            .entitySearchQueries(WorkloadEntitySearchQueryArgs.builder()
                .query("tags.accountId = '12345678' AND tags.environment='production' AND tags.language='java'")
                .build())
            .scopeAccountIds("12345678")
            .build());

    }
}

    resources:
  foo:
    type: newrelic:plugins:Workload
    properties:
      name: Example workload with tags
      accountId: 1.2345678e+07
      entityGuids:
        - MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
      entitySearchQueries:
        - query: tags.accountId = '12345678' AND tags.environment='production' AND tags.language='java'
      scopeAccountIds:
        - 1.2345678e+07

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_plugins_workload" "foo" {
  name         = "Example workload with tags"
  account_id   = 12345678
  entity_guids = ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"]
  entity_search_queries {
    query = "tags.accountId = '12345678' AND tags.environment='production' AND tags.language='java'"
  }
  scope_account_ids = [12345678]
}

    Include automatic status

    The global status of your workload is a quick indicator of the workload health. You can configure it to be calculated automatically, and you can also set an alert and get a notification whenever the workload stops being operational. Alternatively, you can communicate a certain status of the workload by setting up a static value and a description. See our docs

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

const foo = new newrelic.plugins.Workload("foo", {
    name: "Example workload",
    accountId: "12345678",
    entityGuids: ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entitySearchQueries: [{
        query: "name like '%Example application%'",
    }],
    scopeAccountIds: ["12345678"],
    description: "Description",
    statusConfigAutomatic: {
        enabled: true,
        remainingEntitiesRule: {
            remainingEntitiesRuleRollup: {
                strategy: "BEST_STATUS_WINS",
                thresholdType: "FIXED",
                thresholdValue: 100,
                groupBy: "ENTITY_TYPE",
            },
        },
        rules: [{
            entityGuids: ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
            nrqlQueries: [{
                query: "name like '%Example application2%'",
            }],
            rollup: {
                strategy: "BEST_STATUS_WINS",
                thresholdType: "FIXED",
                thresholdValue: 100,
            },
        }],
    },
});

    import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.plugins.Workload("foo",
    name="Example workload",
    account_id="12345678",
    entity_guids=["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entity_search_queries=[{
        "query": "name like '%Example application%'",
    }],
    scope_account_ids=["12345678"],
    description="Description",
    status_config_automatic={
        "enabled": True,
        "remaining_entities_rule": {
            "remaining_entities_rule_rollup": {
                "strategy": "BEST_STATUS_WINS",
                "threshold_type": "FIXED",
                "threshold_value": 100,
                "group_by": "ENTITY_TYPE",
            },
        },
        "rules": [{
            "entity_guids": ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
            "nrql_queries": [{
                "query": "name like '%Example application2%'",
            }],
            "rollup": {
                "strategy": "BEST_STATUS_WINS",
                "threshold_type": "FIXED",
                "threshold_value": 100,
            },
        }],
    })

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := plugins.NewWorkload(ctx, "foo", &plugins.WorkloadArgs{
			Name:      pulumi.String("Example workload"),
			AccountId: pulumi.String("12345678"),
			EntityGuids: pulumi.StringArray{
				pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
			},
			EntitySearchQueries: plugins.WorkloadEntitySearchQueryArray{
				&plugins.WorkloadEntitySearchQueryArgs{
					Query: pulumi.String("name like '%Example application%'"),
				},
			},
			ScopeAccountIds: pulumi.StringArray{
				pulumi.String("12345678"),
			},
			Description: pulumi.String("Description"),
			StatusConfigAutomatic: &plugins.WorkloadStatusConfigAutomaticArgs{
				Enabled: pulumi.Bool(true),
				RemainingEntitiesRule: &plugins.WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs{
					RemainingEntitiesRuleRollup: &plugins.WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs{
						Strategy:       pulumi.String("BEST_STATUS_WINS"),
						ThresholdType:  pulumi.String("FIXED"),
						ThresholdValue: pulumi.Int(100),
						GroupBy:        pulumi.String("ENTITY_TYPE"),
					},
				},
				Rules: plugins.WorkloadStatusConfigAutomaticRuleArray{
					&plugins.WorkloadStatusConfigAutomaticRuleArgs{
						EntityGuids: pulumi.StringArray{
							pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
						},
						NrqlQueries: plugins.WorkloadStatusConfigAutomaticRuleNrqlQueryArray{
							&plugins.WorkloadStatusConfigAutomaticRuleNrqlQueryArgs{
								Query: pulumi.String("name like '%Example application2%'"),
							},
						},
						Rollup: &plugins.WorkloadStatusConfigAutomaticRuleRollupArgs{
							Strategy:       pulumi.String("BEST_STATUS_WINS"),
							ThresholdType:  pulumi.String("FIXED"),
							ThresholdValue: pulumi.Int(100),
						},
					},
				},
			},
		})
		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 = new NewRelic.Plugins.Workload("foo", new()
    {
        Name = "Example workload",
        AccountId = "12345678",
        EntityGuids = new[]
        {
            "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        },
        EntitySearchQueries = new[]
        {
            new NewRelic.Plugins.Inputs.WorkloadEntitySearchQueryArgs
            {
                Query = "name like '%Example application%'",
            },
        },
        ScopeAccountIds = new[]
        {
            "12345678",
        },
        Description = "Description",
        StatusConfigAutomatic = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticArgs
        {
            Enabled = true,
            RemainingEntitiesRule = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs
            {
                RemainingEntitiesRuleRollup = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs
                {
                    Strategy = "BEST_STATUS_WINS",
                    ThresholdType = "FIXED",
                    ThresholdValue = 100,
                    GroupBy = "ENTITY_TYPE",
                },
            },
            Rules = new[]
            {
                new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleArgs
                {
                    EntityGuids = new[]
                    {
                        "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
                    },
                    NrqlQueries = new[]
                    {
                        new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleNrqlQueryArgs
                        {
                            Query = "name like '%Example application2%'",
                        },
                    },
                    Rollup = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleRollupArgs
                    {
                        Strategy = "BEST_STATUS_WINS",
                        ThresholdType = "FIXED",
                        ThresholdValue = 100,
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.plugins.Workload;
import com.pulumi.newrelic.plugins.WorkloadArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadEntitySearchQueryArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigAutomaticArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigAutomaticRuleArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigAutomaticRuleNrqlQueryArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigAutomaticRuleRollupArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 foo = new Workload("foo", WorkloadArgs.builder()
            .name("Example workload")
            .accountId("12345678")
            .entityGuids("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1")
            .entitySearchQueries(WorkloadEntitySearchQueryArgs.builder()
                .query("name like '%Example application%'")
                .build())
            .scopeAccountIds("12345678")
            .description("Description")
            .statusConfigAutomatic(WorkloadStatusConfigAutomaticArgs.builder()
                .enabled(true)
                .remainingEntitiesRule(WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs.builder()
                    .remainingEntitiesRuleRollup(WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs.builder()
                        .strategy("BEST_STATUS_WINS")
                        .thresholdType("FIXED")
                        .thresholdValue(100)
                        .groupBy("ENTITY_TYPE")
                        .build())
                    .build())
                .rules(WorkloadStatusConfigAutomaticRuleArgs.builder()
                    .entityGuids("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1")
                    .nrqlQueries(WorkloadStatusConfigAutomaticRuleNrqlQueryArgs.builder()
                        .query("name like '%Example application2%'")
                        .build())
                    .rollup(WorkloadStatusConfigAutomaticRuleRollupArgs.builder()
                        .strategy("BEST_STATUS_WINS")
                        .thresholdType("FIXED")
                        .thresholdValue(100)
                        .build())
                    .build())
                .build())
            .build());

    }
}

    resources:
  foo:
    type: newrelic:plugins:Workload
    properties:
      name: Example workload
      accountId: 1.2345678e+07
      entityGuids:
        - MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
      entitySearchQueries:
        - query: name like '%Example application%'
      scopeAccountIds:
        - 1.2345678e+07
      description: Description
      statusConfigAutomatic:
        enabled: true
        remainingEntitiesRule:
          remainingEntitiesRuleRollup:
            strategy: BEST_STATUS_WINS
            thresholdType: FIXED
            thresholdValue: 100
            groupBy: ENTITY_TYPE
        rules:
          - entityGuids:
              - MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
            nrqlQueries:
              - query: name like '%Example application2%'
            rollup:
              strategy: BEST_STATUS_WINS
              thresholdType: FIXED
              thresholdValue: 100

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_plugins_workload" "foo" {
  name         = "Example workload"
  account_id   = 12345678
  entity_guids = ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"]
  entity_search_queries {
    query = "name like '%Example application%'"
  }
  scope_account_ids = [12345678]
  description       = "Description"
  status_config_automatic = {
    enabled = true
    remaining_entities_rule = {
      remaining_entities_rule_rollup = {
        strategy        = "BEST_STATUS_WINS"
        threshold_type  = "FIXED"
        threshold_value = 100
        group_by        = "ENTITY_TYPE"
      }
    }
    rules = [{
      "entityGuids" = ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"]
      "nrqlQueries" = [{
        "query" = "name like '%Example application2%'"
      }]
      "rollup" = {
        "strategy"       = "BEST_STATUS_WINS"
        "thresholdType"  = "FIXED"
        "thresholdValue" = 100
      }
    }]
  }
}

    Include static status

    You can use this during maintenance tasks or any other time you want to provide a fixed status for your workload. This overrides all automatic rules. See our docs

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

const foo = new newrelic.plugins.Workload("foo", {
    name: "Example workload",
    accountId: "12345678",
    entityGuids: ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entitySearchQueries: [{
        query: "name like '%Example application%'",
    }],
    scopeAccountIds: ["12345678"],
    description: "Description",
    statusConfigStatic: {
        description: "test",
        enabled: true,
        status: "OPERATIONAL",
        summary: "summary of the status",
    },
});

    import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.plugins.Workload("foo",
    name="Example workload",
    account_id="12345678",
    entity_guids=["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"],
    entity_search_queries=[{
        "query": "name like '%Example application%'",
    }],
    scope_account_ids=["12345678"],
    description="Description",
    status_config_static={
        "description": "test",
        "enabled": True,
        "status": "OPERATIONAL",
        "summary": "summary of the status",
    })

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := plugins.NewWorkload(ctx, "foo", &plugins.WorkloadArgs{
			Name:      pulumi.String("Example workload"),
			AccountId: pulumi.String("12345678"),
			EntityGuids: pulumi.StringArray{
				pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
			},
			EntitySearchQueries: plugins.WorkloadEntitySearchQueryArray{
				&plugins.WorkloadEntitySearchQueryArgs{
					Query: pulumi.String("name like '%Example application%'"),
				},
			},
			ScopeAccountIds: pulumi.StringArray{
				pulumi.String("12345678"),
			},
			Description: pulumi.String("Description"),
			StatusConfigStatic: &plugins.WorkloadStatusConfigStaticArgs{
				Description: pulumi.String("test"),
				Enabled:     pulumi.Bool(true),
				Status:      pulumi.String("OPERATIONAL"),
				Summary:     pulumi.String("summary of the status"),
			},
		})
		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 = new NewRelic.Plugins.Workload("foo", new()
    {
        Name = "Example workload",
        AccountId = "12345678",
        EntityGuids = new[]
        {
            "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        },
        EntitySearchQueries = new[]
        {
            new NewRelic.Plugins.Inputs.WorkloadEntitySearchQueryArgs
            {
                Query = "name like '%Example application%'",
            },
        },
        ScopeAccountIds = new[]
        {
            "12345678",
        },
        Description = "Description",
        StatusConfigStatic = new NewRelic.Plugins.Inputs.WorkloadStatusConfigStaticArgs
        {
            Description = "test",
            Enabled = true,
            Status = "OPERATIONAL",
            Summary = "summary of the status",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.plugins.Workload;
import com.pulumi.newrelic.plugins.WorkloadArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadEntitySearchQueryArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigStaticArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 foo = new Workload("foo", WorkloadArgs.builder()
            .name("Example workload")
            .accountId("12345678")
            .entityGuids("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1")
            .entitySearchQueries(WorkloadEntitySearchQueryArgs.builder()
                .query("name like '%Example application%'")
                .build())
            .scopeAccountIds("12345678")
            .description("Description")
            .statusConfigStatic(WorkloadStatusConfigStaticArgs.builder()
                .description("test")
                .enabled(true)
                .status("OPERATIONAL")
                .summary("summary of the status")
                .build())
            .build());

    }
}

    resources:
  foo:
    type: newrelic:plugins:Workload
    properties:
      name: Example workload
      accountId: 1.2345678e+07
      entityGuids:
        - MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
      entitySearchQueries:
        - query: name like '%Example application%'
      scopeAccountIds:
        - 1.2345678e+07
      description: Description
      statusConfigStatic:
        description: test
        enabled: true
        status: OPERATIONAL
        summary: summary of the status

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_plugins_workload" "foo" {
  name         = "Example workload"
  account_id   = 12345678
  entity_guids = ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"]
  entity_search_queries {
    query = "name like '%Example application%'"
  }
  scope_account_ids = [12345678]
  description       = "Description"
  status_config_static = {
    description = "test"
    enabled     = true
    status      = "OPERATIONAL"
    summary     = "summary of the status"
  }
}

    Intelligent Workload

    An intelligent workload uses dynamicFlows to anchor the workload to a transaction entry point. New Relic automatically discovers and refreshes the related entities using Transaction 360 distributed tracing data — no manual entity selection required. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. The statusConfigAlertPolicy block derives workload health from the alert state of its entities and requires dynamicFlows to be set; statusConfigAutomatic and statusConfigStatic remain available. See our docs

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

const intelligent = new newrelic.plugins.Workload("intelligent", {
    name: "Example intelligent workload",
    accountId: "12345678",
    dynamicFlows: [{
        entityGuid: "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        transactionName: "WebTransaction/Action/index",
    }],
    scopeAccountIds: ["12345678"],
});

    import pulumi
import pulumi_newrelic as newrelic

intelligent = newrelic.plugins.Workload("intelligent",
    name="Example intelligent workload",
    account_id="12345678",
    dynamic_flows=[{
        "entity_guid": "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        "transaction_name": "WebTransaction/Action/index",
    }],
    scope_account_ids=["12345678"])

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := plugins.NewWorkload(ctx, "intelligent", &plugins.WorkloadArgs{
			Name:      pulumi.String("Example intelligent workload"),
			AccountId: pulumi.String("12345678"),
			DynamicFlows: plugins.WorkloadDynamicFlowArray{
				&plugins.WorkloadDynamicFlowArgs{
					EntityGuid:      pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
					TransactionName: pulumi.String("WebTransaction/Action/index"),
				},
			},
			ScopeAccountIds: pulumi.StringArray{
				pulumi.String("12345678"),
			},
		})
		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 intelligent = new NewRelic.Plugins.Workload("intelligent", new()
    {
        Name = "Example intelligent workload",
        AccountId = "12345678",
        DynamicFlows = new[]
        {
            new NewRelic.Plugins.Inputs.WorkloadDynamicFlowArgs
            {
                EntityGuid = "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
                TransactionName = "WebTransaction/Action/index",
            },
        },
        ScopeAccountIds = new[]
        {
            "12345678",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.plugins.Workload;
import com.pulumi.newrelic.plugins.WorkloadArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadDynamicFlowArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 intelligent = new Workload("intelligent", WorkloadArgs.builder()
            .name("Example intelligent workload")
            .accountId("12345678")
            .dynamicFlows(WorkloadDynamicFlowArgs.builder()
                .entityGuid("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1")
                .transactionName("WebTransaction/Action/index")
                .build())
            .scopeAccountIds("12345678")
            .build());

    }
}

    resources:
  intelligent:
    type: newrelic:plugins:Workload
    properties:
      name: Example intelligent workload
      accountId: 1.2345678e+07 # Intelligent workloads use dynamic_flows to define the transaction entry point.
      #   # New Relic auto-discovers all related entities via distributed tracing (Transaction 360).
      #   # If it is set alongside entity_guids or entity_search_query, dynamic_flows takes precedence.
      dynamicFlows:
        - entityGuid: MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
          transactionName: WebTransaction/Action/index
      scopeAccountIds:
        - 1.2345678e+07

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_plugins_workload" "intelligent" {
  name       = "Example intelligent workload"
  account_id = 12345678
  # Intelligent workloads use dynamic_flows to define the transaction entry point.
  # New Relic auto-discovers all related entities via distributed tracing (Transaction 360).
  # If it is set alongside entity_guids or entity_search_query, dynamic_flows takes precedence.
  dynamic_flows {
    entity_guid      = "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"
    transaction_name = "WebTransaction/Action/index"
  }
  scope_account_ids = [12345678]
}

    Intelligent Workload with Alert Condition

    BETA PREVIEW: targetEntity in newrelic.NrqlAlertCondition is in limited release and only enabled for preview on a per-account basis. Once an intelligent workload is created with statusConfigAlertPolicy enabled, alert conditions can be attached by referencing the workload’s guid (available post-apply as newrelic_workload.<resource_label>.guid) as targetEntity. The workload health is then derived from the alert states of those conditions.

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

const intelligent = new newrelic.plugins.Workload("intelligent", {
    name: "Example intelligent workload",
    accountId: "12345678",
    dynamicFlows: [{
        entityGuid: "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        transactionName: "WebTransaction/Action/index",
    }],
    scopeAccountIds: ["12345678"],
    statusConfigAlertPolicy: {
        enabled: true,
    },
});
const foo = new newrelic.AlertPolicy("foo", {name: "foo"});
const fooNrqlAlertCondition = new newrelic.NrqlAlertCondition("foo", {
    accountId: "12345678",
    policyId: foo.id,
    type: "static",
    name: "foo",
    enabled: true,
    violationTimeLimitSeconds: 3600,
    targetEntity: intelligent.guid,
    nrql: {
        query: "SELECT count(*) FROM Transaction WHERE appName = 'Your App'",
    },
    critical: {
        operator: "above",
        threshold: 5.5,
        thresholdDuration: 300,
        thresholdOccurrences: "ALL",
    },
});

    import pulumi
import pulumi_newrelic as newrelic

intelligent = newrelic.plugins.Workload("intelligent",
    name="Example intelligent workload",
    account_id="12345678",
    dynamic_flows=[{
        "entity_guid": "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        "transaction_name": "WebTransaction/Action/index",
    }],
    scope_account_ids=["12345678"],
    status_config_alert_policy={
        "enabled": True,
    })
foo = newrelic.AlertPolicy("foo", name="foo")
foo_nrql_alert_condition = newrelic.NrqlAlertCondition("foo",
    account_id="12345678",
    policy_id=foo.id,
    type="static",
    name="foo",
    enabled=True,
    violation_time_limit_seconds=3600,
    target_entity=intelligent.guid,
    nrql={
        "query": "SELECT count(*) FROM Transaction WHERE appName = 'Your App'",
    },
    critical={
        "operator": "above",
        "threshold": 5.5,
        "threshold_duration": 300,
        "threshold_occurrences": "ALL",
    })

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		intelligent, err := plugins.NewWorkload(ctx, "intelligent", &plugins.WorkloadArgs{
			Name:      pulumi.String("Example intelligent workload"),
			AccountId: pulumi.String("12345678"),
			DynamicFlows: plugins.WorkloadDynamicFlowArray{
				&plugins.WorkloadDynamicFlowArgs{
					EntityGuid:      pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
					TransactionName: pulumi.String("WebTransaction/Action/index"),
				},
			},
			ScopeAccountIds: pulumi.StringArray{
				pulumi.String("12345678"),
			},
			StatusConfigAlertPolicy: &plugins.WorkloadStatusConfigAlertPolicyArgs{
				Enabled: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		foo, err := newrelic.NewAlertPolicy(ctx, "foo", &newrelic.AlertPolicyArgs{
			Name: pulumi.String("foo"),
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewNrqlAlertCondition(ctx, "foo", &newrelic.NrqlAlertConditionArgs{
			AccountId:                 pulumi.String("12345678"),
			PolicyId:                  foo.ID(),
			Type:                      pulumi.String("static"),
			Name:                      pulumi.String("foo"),
			Enabled:                   pulumi.Bool(true),
			ViolationTimeLimitSeconds: pulumi.Int(3600),
			TargetEntity:              intelligent.Guid,
			Nrql: &newrelic.NrqlAlertConditionNrqlArgs{
				Query: pulumi.String("SELECT count(*) FROM Transaction WHERE appName = 'Your App'"),
			},
			Critical: &newrelic.NrqlAlertConditionCriticalArgs{
				Operator:             pulumi.String("above"),
				Threshold:            pulumi.Float64(5.5),
				ThresholdDuration:    pulumi.Int(300),
				ThresholdOccurrences: pulumi.String("ALL"),
			},
		})
		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 intelligent = new NewRelic.Plugins.Workload("intelligent", new()
    {
        Name = "Example intelligent workload",
        AccountId = "12345678",
        DynamicFlows = new[]
        {
            new NewRelic.Plugins.Inputs.WorkloadDynamicFlowArgs
            {
                EntityGuid = "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
                TransactionName = "WebTransaction/Action/index",
            },
        },
        ScopeAccountIds = new[]
        {
            "12345678",
        },
        StatusConfigAlertPolicy = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAlertPolicyArgs
        {
            Enabled = true,
        },
    });

    var foo = new NewRelic.AlertPolicy("foo", new()
    {
        Name = "foo",
    });

    var fooNrqlAlertCondition = new NewRelic.NrqlAlertCondition("foo", new()
    {
        AccountId = "12345678",
        PolicyId = foo.Id,
        Type = "static",
        Name = "foo",
        Enabled = true,
        ViolationTimeLimitSeconds = 3600,
        TargetEntity = intelligent.Guid,
        Nrql = new NewRelic.Inputs.NrqlAlertConditionNrqlArgs
        {
            Query = "SELECT count(*) FROM Transaction WHERE appName = 'Your App'",
        },
        Critical = new NewRelic.Inputs.NrqlAlertConditionCriticalArgs
        {
            Operator = "above",
            Threshold = 5.5,
            ThresholdDuration = 300,
            ThresholdOccurrences = "ALL",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.plugins.Workload;
import com.pulumi.newrelic.plugins.WorkloadArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadDynamicFlowArgs;
import com.pulumi.newrelic.plugins.inputs.WorkloadStatusConfigAlertPolicyArgs;
import com.pulumi.newrelic.AlertPolicy;
import com.pulumi.newrelic.AlertPolicyArgs;
import com.pulumi.newrelic.NrqlAlertCondition;
import com.pulumi.newrelic.NrqlAlertConditionArgs;
import com.pulumi.newrelic.inputs.NrqlAlertConditionNrqlArgs;
import com.pulumi.newrelic.inputs.NrqlAlertConditionCriticalArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 intelligent = new Workload("intelligent", WorkloadArgs.builder()
            .name("Example intelligent workload")
            .accountId("12345678")
            .dynamicFlows(WorkloadDynamicFlowArgs.builder()
                .entityGuid("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1")
                .transactionName("WebTransaction/Action/index")
                .build())
            .scopeAccountIds("12345678")
            .statusConfigAlertPolicy(WorkloadStatusConfigAlertPolicyArgs.builder()
                .enabled(true)
                .build())
            .build());

        var foo = new AlertPolicy("foo", AlertPolicyArgs.builder()
            .name("foo")
            .build());

        var fooNrqlAlertCondition = new NrqlAlertCondition("fooNrqlAlertCondition", NrqlAlertConditionArgs.builder()
            .accountId("12345678")
            .policyId(foo.id())
            .type("static")
            .name("foo")
            .enabled(true)
            .violationTimeLimitSeconds(3600)
            .targetEntity(intelligent.guid())
            .nrql(NrqlAlertConditionNrqlArgs.builder()
                .query("SELECT count(*) FROM Transaction WHERE appName = 'Your App'")
                .build())
            .critical(NrqlAlertConditionCriticalArgs.builder()
                .operator("above")
                .threshold(5.5)
                .thresholdDuration(300)
                .thresholdOccurrences("ALL")
                .build())
            .build());

    }
}

    resources:
  intelligent:
    type: newrelic:plugins:Workload
    properties:
      name: Example intelligent workload
      accountId: 1.2345678e+07 # Intelligent workloads use dynamic_flows to define the transaction entry point.
      #   # New Relic auto-discovers all related entities via distributed tracing (Transaction 360).
      #   # If it is set alongside entity_guids or entity_search_query, dynamic_flows takes precedence.
      dynamicFlows:
        - entityGuid: MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
          transactionName: WebTransaction/Action/index
      scopeAccountIds:
        - 1.2345678e+07
      statusConfigAlertPolicy:
        enabled: true
  foo:
    type: newrelic:AlertPolicy
    properties:
      name: foo
  fooNrqlAlertCondition:
    type: newrelic:NrqlAlertCondition
    name: foo
    properties:
      accountId: 1.2345678e+07
      policyId: ${foo.id}
      type: static
      name: foo
      enabled: true
      violationTimeLimitSeconds: 3600
      targetEntity: ${intelligent.guid}
      nrql:
        query: SELECT count(*) FROM Transaction WHERE appName = 'Your App'
      critical:
        operator: above
        threshold: 5.5
        thresholdDuration: 300
        thresholdOccurrences: ALL

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_plugins_workload" "intelligent" {
  name       = "Example intelligent workload"
  account_id = 12345678
  # Intelligent workloads use dynamic_flows to define the transaction entry point.
  # New Relic auto-discovers all related entities via distributed tracing (Transaction 360).
  # If it is set alongside entity_guids or entity_search_query, dynamic_flows takes precedence.
  dynamic_flows {
    entity_guid      = "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"
    transaction_name = "WebTransaction/Action/index"
  }
  scope_account_ids = [12345678]
  status_config_alert_policy = {
    enabled = true
  }
}
resource "newrelic_alertpolicy" "foo" {
  name = "foo"
}
resource "newrelic_nrqlalertcondition" "foo" {
  account_id                   = 12345678
  policy_id                    = newrelic_alertpolicy.foo.id
  type                         = "static"
  name                         = "foo"
  enabled                      = true
  violation_time_limit_seconds = 3600
  target_entity                = newrelic_plugins_workload.intelligent.guid
  nrql = {
    query = "SELECT count(*) FROM Transaction WHERE appName = 'Your App'"
  }
  critical = {
    operator              = "above"
    threshold             = 5.5
    threshold_duration    = 300
    threshold_occurrences = "ALL"
  }
}

    Create Workload Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Workload(name: string, args?: WorkloadArgs, opts?: CustomResourceOptions);
    @overload
def Workload(resource_name: str,
             args: Optional[WorkloadArgs] = None,
             opts: Optional[ResourceOptions] = None)

@overload
def Workload(resource_name: str,
             opts: Optional[ResourceOptions] = None,
             account_id: Optional[str] = None,
             description: Optional[str] = None,
             dynamic_flows: Optional[Sequence[WorkloadDynamicFlowArgs]] = None,
             entity_guids: Optional[Sequence[str]] = None,
             entity_search_queries: Optional[Sequence[WorkloadEntitySearchQueryArgs]] = None,
             name: Optional[str] = None,
             scope_account_ids: Optional[Sequence[str]] = None,
             status_config_alert_policy: Optional[WorkloadStatusConfigAlertPolicyArgs] = None,
             status_config_automatic: Optional[WorkloadStatusConfigAutomaticArgs] = None,
             status_config_static: Optional[WorkloadStatusConfigStaticArgs] = None)
    func NewWorkload(ctx *Context, name string, args *WorkloadArgs, opts ...ResourceOption) (*Workload, error)
    public Workload(string name, WorkloadArgs? args = null, CustomResourceOptions? opts = null)
    public Workload(String name, WorkloadArgs args)
public Workload(String name, WorkloadArgs args, CustomResourceOptions options)

    type: newrelic:plugins:Workload
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "newrelic_plugins_workload" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args WorkloadArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args WorkloadArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args WorkloadArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args WorkloadArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args WorkloadArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var workloadResource = new NewRelic.Plugins.Workload("workloadResource", new()
{
    AccountId = "string",
    Description = "string",
    DynamicFlows = new[]
    {
        new NewRelic.Plugins.Inputs.WorkloadDynamicFlowArgs
        {
            EntityGuid = "string",
            TransactionName = "string",
        },
    },
    EntityGuids = new[]
    {
        "string",
    },
    EntitySearchQueries = new[]
    {
        new NewRelic.Plugins.Inputs.WorkloadEntitySearchQueryArgs
        {
            Query = "string",
        },
    },
    Name = "string",
    ScopeAccountIds = new[]
    {
        "string",
    },
    StatusConfigAlertPolicy = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAlertPolicyArgs
    {
        Enabled = false,
    },
    StatusConfigAutomatic = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticArgs
    {
        Enabled = false,
        RemainingEntitiesRule = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs
        {
            RemainingEntitiesRuleRollup = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs
            {
                GroupBy = "string",
                Strategy = "string",
                ThresholdType = "string",
                ThresholdValue = 0,
            },
        },
        Rules = new[]
        {
            new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleArgs
            {
                Rollup = new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleRollupArgs
                {
                    Strategy = "string",
                    ThresholdType = "string",
                    ThresholdValue = 0,
                },
                EntityGuids = new[]
                {
                    "string",
                },
                NrqlQueries = new[]
                {
                    new NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleNrqlQueryArgs
                    {
                        Query = "string",
                    },
                },
            },
        },
    },
    StatusConfigStatic = new NewRelic.Plugins.Inputs.WorkloadStatusConfigStaticArgs
    {
        Enabled = false,
        Status = "string",
        Description = "string",
        Summary = "string",
    },
});

    example, err := plugins.NewWorkload(ctx, "workloadResource", &plugins.WorkloadArgs{
	AccountId:   pulumi.String("string"),
	Description: pulumi.String("string"),
	DynamicFlows: plugins.WorkloadDynamicFlowArray{
		&plugins.WorkloadDynamicFlowArgs{
			EntityGuid:      pulumi.String("string"),
			TransactionName: pulumi.String("string"),
		},
	},
	EntityGuids: pulumi.StringArray{
		pulumi.String("string"),
	},
	EntitySearchQueries: plugins.WorkloadEntitySearchQueryArray{
		&plugins.WorkloadEntitySearchQueryArgs{
			Query: pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
	ScopeAccountIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	StatusConfigAlertPolicy: &plugins.WorkloadStatusConfigAlertPolicyArgs{
		Enabled: pulumi.Bool(false),
	},
	StatusConfigAutomatic: &plugins.WorkloadStatusConfigAutomaticArgs{
		Enabled: pulumi.Bool(false),
		RemainingEntitiesRule: &plugins.WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs{
			RemainingEntitiesRuleRollup: &plugins.WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs{
				GroupBy:        pulumi.String("string"),
				Strategy:       pulumi.String("string"),
				ThresholdType:  pulumi.String("string"),
				ThresholdValue: pulumi.Int(0),
			},
		},
		Rules: plugins.WorkloadStatusConfigAutomaticRuleArray{
			&plugins.WorkloadStatusConfigAutomaticRuleArgs{
				Rollup: &plugins.WorkloadStatusConfigAutomaticRuleRollupArgs{
					Strategy:       pulumi.String("string"),
					ThresholdType:  pulumi.String("string"),
					ThresholdValue: pulumi.Int(0),
				},
				EntityGuids: pulumi.StringArray{
					pulumi.String("string"),
				},
				NrqlQueries: plugins.WorkloadStatusConfigAutomaticRuleNrqlQueryArray{
					&plugins.WorkloadStatusConfigAutomaticRuleNrqlQueryArgs{
						Query: pulumi.String("string"),
					},
				},
			},
		},
	},
	StatusConfigStatic: &plugins.WorkloadStatusConfigStaticArgs{
		Enabled:     pulumi.Bool(false),
		Status:      pulumi.String("string"),
		Description: pulumi.String("string"),
		Summary:     pulumi.String("string"),
	},
})

    resource "newrelic_plugins_workload" "workloadResource" {
  account_id  = "string"
  description = "string"
  dynamic_flows {
    entity_guid      = "string"
    transaction_name = "string"
  }
  entity_guids = ["string"]
  entity_search_queries {
    query = "string"
  }
  name              = "string"
  scope_account_ids = ["string"]
  status_config_alert_policy = {
    enabled = false
  }
  status_config_automatic = {
    enabled = false
    remaining_entities_rule = {
      remaining_entities_rule_rollup = {
        group_by        = "string"
        strategy        = "string"
        threshold_type  = "string"
        threshold_value = 0
      }
    }
    rules = [{
      "rollup" = {
        "strategy"       = "string"
        "thresholdType"  = "string"
        "thresholdValue" = 0
      }
      "entityGuids" = ["string"]
      "nrqlQueries" = [{
        "query" = "string"
      }]
    }]
  }
  status_config_static = {
    enabled     = false
    status      = "string"
    description = "string"
    summary     = "string"
  }
}

    var workloadResource = new Workload("workloadResource", WorkloadArgs.builder()
    .accountId("string")
    .description("string")
    .dynamicFlows(WorkloadDynamicFlowArgs.builder()
        .entityGuid("string")
        .transactionName("string")
        .build())
    .entityGuids("string")
    .entitySearchQueries(WorkloadEntitySearchQueryArgs.builder()
        .query("string")
        .build())
    .name("string")
    .scopeAccountIds("string")
    .statusConfigAlertPolicy(WorkloadStatusConfigAlertPolicyArgs.builder()
        .enabled(false)
        .build())
    .statusConfigAutomatic(WorkloadStatusConfigAutomaticArgs.builder()
        .enabled(false)
        .remainingEntitiesRule(WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs.builder()
            .remainingEntitiesRuleRollup(WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs.builder()
                .groupBy("string")
                .strategy("string")
                .thresholdType("string")
                .thresholdValue(0)
                .build())
            .build())
        .rules(WorkloadStatusConfigAutomaticRuleArgs.builder()
            .rollup(WorkloadStatusConfigAutomaticRuleRollupArgs.builder()
                .strategy("string")
                .thresholdType("string")
                .thresholdValue(0)
                .build())
            .entityGuids("string")
            .nrqlQueries(WorkloadStatusConfigAutomaticRuleNrqlQueryArgs.builder()
                .query("string")
                .build())
            .build())
        .build())
    .statusConfigStatic(WorkloadStatusConfigStaticArgs.builder()
        .enabled(false)
        .status("string")
        .description("string")
        .summary("string")
        .build())
    .build());

    workload_resource = newrelic.plugins.Workload("workloadResource",
    account_id="string",
    description="string",
    dynamic_flows=[{
        "entity_guid": "string",
        "transaction_name": "string",
    }],
    entity_guids=["string"],
    entity_search_queries=[{
        "query": "string",
    }],
    name="string",
    scope_account_ids=["string"],
    status_config_alert_policy={
        "enabled": False,
    },
    status_config_automatic={
        "enabled": False,
        "remaining_entities_rule": {
            "remaining_entities_rule_rollup": {
                "group_by": "string",
                "strategy": "string",
                "threshold_type": "string",
                "threshold_value": 0,
            },
        },
        "rules": [{
            "rollup": {
                "strategy": "string",
                "threshold_type": "string",
                "threshold_value": 0,
            },
            "entity_guids": ["string"],
            "nrql_queries": [{
                "query": "string",
            }],
        }],
    },
    status_config_static={
        "enabled": False,
        "status": "string",
        "description": "string",
        "summary": "string",
    })

    const workloadResource = new newrelic.plugins.Workload("workloadResource", {
    accountId: "string",
    description: "string",
    dynamicFlows: [{
        entityGuid: "string",
        transactionName: "string",
    }],
    entityGuids: ["string"],
    entitySearchQueries: [{
        query: "string",
    }],
    name: "string",
    scopeAccountIds: ["string"],
    statusConfigAlertPolicy: {
        enabled: false,
    },
    statusConfigAutomatic: {
        enabled: false,
        remainingEntitiesRule: {
            remainingEntitiesRuleRollup: {
                groupBy: "string",
                strategy: "string",
                thresholdType: "string",
                thresholdValue: 0,
            },
        },
        rules: [{
            rollup: {
                strategy: "string",
                thresholdType: "string",
                thresholdValue: 0,
            },
            entityGuids: ["string"],
            nrqlQueries: [{
                query: "string",
            }],
        }],
    },
    statusConfigStatic: {
        enabled: false,
        status: "string",
        description: "string",
        summary: "string",
    },
});

    type: newrelic:plugins:Workload
properties:
    accountId: string
    description: string
    dynamicFlows:
        - entityGuid: string
          transactionName: string
    entityGuids:
        - string
    entitySearchQueries:
        - query: string
    name: string
    scopeAccountIds:
        - string
    statusConfigAlertPolicy:
        enabled: false
    statusConfigAutomatic:
        enabled: false
        remainingEntitiesRule:
            remainingEntitiesRuleRollup:
                groupBy: string
                strategy: string
                thresholdType: string
                thresholdValue: 0
        rules:
            - entityGuids:
                - string
              nrqlQueries:
                - query: string
              rollup:
                strategy: string
                thresholdType: string
                thresholdValue: 0
    statusConfigStatic:
        description: string
        enabled: false
        status: string
        summary: string

    Workload Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Workload resource accepts the following input properties:

    AccountId string
    The New Relic account ID where you want to create the workload.
    Description string
    Relevant information about the workload.
    DynamicFlows List<Pulumi.NewRelic.Plugins.Inputs.WorkloadDynamicFlow>
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    EntityGuids List<string>
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    EntitySearchQueries List<Pulumi.NewRelic.Plugins.Inputs.WorkloadEntitySearchQuery>
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    Name string
    The workload's name.
    ScopeAccountIds List<string>
    A list of account IDs that will be used to get entities from.
    StatusConfigAlertPolicy Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAlertPolicy
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    StatusConfigAutomatic Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomatic
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    StatusConfigStatic Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigStatic
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    AccountId string
    The New Relic account ID where you want to create the workload.
    Description string
    Relevant information about the workload.
    DynamicFlows []WorkloadDynamicFlowArgs
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    EntityGuids []string
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    EntitySearchQueries []WorkloadEntitySearchQueryArgs
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    Name string
    The workload's name.
    ScopeAccountIds []string
    A list of account IDs that will be used to get entities from.
    StatusConfigAlertPolicy WorkloadStatusConfigAlertPolicyArgs
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    StatusConfigAutomatic WorkloadStatusConfigAutomaticArgs
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    StatusConfigStatic WorkloadStatusConfigStaticArgs
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    account_id string
    The New Relic account ID where you want to create the workload.
    description string
    Relevant information about the workload.
    dynamic_flows list(object)
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entity_guids list(string)
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entity_search_queries list(object)
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    name string
    The workload's name.
    scope_account_ids list(string)
    A list of account IDs that will be used to get entities from.
    status_config_alert_policy object
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    status_config_automatic object
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    status_config_static object
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    accountId String
    The New Relic account ID where you want to create the workload.
    description String
    Relevant information about the workload.
    dynamicFlows List<WorkloadDynamicFlow>
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entityGuids List<String>
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entitySearchQueries List<WorkloadEntitySearchQuery>
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    name String
    The workload's name.
    scopeAccountIds List<String>
    A list of account IDs that will be used to get entities from.
    statusConfigAlertPolicy WorkloadStatusConfigAlertPolicy
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    statusConfigAutomatic WorkloadStatusConfigAutomatic
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    statusConfigStatic WorkloadStatusConfigStatic
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    accountId string
    The New Relic account ID where you want to create the workload.
    description string
    Relevant information about the workload.
    dynamicFlows WorkloadDynamicFlow[]
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entityGuids string[]
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entitySearchQueries WorkloadEntitySearchQuery[]
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    name string
    The workload's name.
    scopeAccountIds string[]
    A list of account IDs that will be used to get entities from.
    statusConfigAlertPolicy WorkloadStatusConfigAlertPolicy
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    statusConfigAutomatic WorkloadStatusConfigAutomatic
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    statusConfigStatic WorkloadStatusConfigStatic
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    account_id str
    The New Relic account ID where you want to create the workload.
    description str
    Relevant information about the workload.
    dynamic_flows Sequence[WorkloadDynamicFlowArgs]
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entity_guids Sequence[str]
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entity_search_queries Sequence[WorkloadEntitySearchQueryArgs]
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    name str
    The workload's name.
    scope_account_ids Sequence[str]
    A list of account IDs that will be used to get entities from.
    status_config_alert_policy WorkloadStatusConfigAlertPolicyArgs
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    status_config_automatic WorkloadStatusConfigAutomaticArgs
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    status_config_static WorkloadStatusConfigStaticArgs
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    accountId String
    The New Relic account ID where you want to create the workload.
    description String
    Relevant information about the workload.
    dynamicFlows List<Property Map>
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entityGuids List<String>
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entitySearchQueries List<Property Map>
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    name String
    The workload's name.
    scopeAccountIds List<String>
    A list of account IDs that will be used to get entities from.
    statusConfigAlertPolicy Property Map
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    statusConfigAutomatic Property Map
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    statusConfigStatic Property Map
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Workload resource produces the following output properties:

    CompositeEntitySearchQuery string
    The composite query used to compose a dynamic workload.
    Guid string
    The unique entity identifier of the workload in New Relic.
    Id string
    The provider-assigned unique ID for this managed resource.
    Permalink string
    The URL of the workload.
    WorkloadId string
    The unique entity identifier of the workload.
    CompositeEntitySearchQuery string
    The composite query used to compose a dynamic workload.
    Guid string
    The unique entity identifier of the workload in New Relic.
    Id string
    The provider-assigned unique ID for this managed resource.
    Permalink string
    The URL of the workload.
    WorkloadId string
    The unique entity identifier of the workload.
    composite_entity_search_query string
    The composite query used to compose a dynamic workload.
    guid string
    The unique entity identifier of the workload in New Relic.
    id string
    The provider-assigned unique ID for this managed resource.
    permalink string
    The URL of the workload.
    workload_id string
    The unique entity identifier of the workload.
    compositeEntitySearchQuery String
    The composite query used to compose a dynamic workload.
    guid String
    The unique entity identifier of the workload in New Relic.
    id String
    The provider-assigned unique ID for this managed resource.
    permalink String
    The URL of the workload.
    workloadId String
    The unique entity identifier of the workload.
    compositeEntitySearchQuery string
    The composite query used to compose a dynamic workload.
    guid string
    The unique entity identifier of the workload in New Relic.
    id string
    The provider-assigned unique ID for this managed resource.
    permalink string
    The URL of the workload.
    workloadId string
    The unique entity identifier of the workload.
    composite_entity_search_query str
    The composite query used to compose a dynamic workload.
    guid str
    The unique entity identifier of the workload in New Relic.
    id str
    The provider-assigned unique ID for this managed resource.
    permalink str
    The URL of the workload.
    workload_id str
    The unique entity identifier of the workload.
    compositeEntitySearchQuery String
    The composite query used to compose a dynamic workload.
    guid String
    The unique entity identifier of the workload in New Relic.
    id String
    The provider-assigned unique ID for this managed resource.
    permalink String
    The URL of the workload.
    workloadId String
    The unique entity identifier of the workload.

    Look up Existing Workload Resource

    Get an existing Workload resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: WorkloadState, opts?: CustomResourceOptions): Workload
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        account_id: Optional[str] = None,
        composite_entity_search_query: Optional[str] = None,
        description: Optional[str] = None,
        dynamic_flows: Optional[Sequence[WorkloadDynamicFlowArgs]] = None,
        entity_guids: Optional[Sequence[str]] = None,
        entity_search_queries: Optional[Sequence[WorkloadEntitySearchQueryArgs]] = None,
        guid: Optional[str] = None,
        name: Optional[str] = None,
        permalink: Optional[str] = None,
        scope_account_ids: Optional[Sequence[str]] = None,
        status_config_alert_policy: Optional[WorkloadStatusConfigAlertPolicyArgs] = None,
        status_config_automatic: Optional[WorkloadStatusConfigAutomaticArgs] = None,
        status_config_static: Optional[WorkloadStatusConfigStaticArgs] = None,
        workload_id: Optional[str] = None) -> Workload
    func GetWorkload(ctx *Context, name string, id IDInput, state *WorkloadState, opts ...ResourceOption) (*Workload, error)
    public static Workload Get(string name, Input<string> id, WorkloadState? state, CustomResourceOptions? opts = null)
    public static Workload get(String name, Output<String> id, WorkloadState state, CustomResourceOptions options)
    resources:  _:    type: newrelic:plugins:Workload    get:      id: ${id}
    import {
  to = newrelic_plugins_workload.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    AccountId string
    The New Relic account ID where you want to create the workload.
    CompositeEntitySearchQuery string
    The composite query used to compose a dynamic workload.
    Description string
    Relevant information about the workload.
    DynamicFlows List<Pulumi.NewRelic.Plugins.Inputs.WorkloadDynamicFlow>
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    EntityGuids List<string>
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    EntitySearchQueries List<Pulumi.NewRelic.Plugins.Inputs.WorkloadEntitySearchQuery>
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    Guid string
    The unique entity identifier of the workload in New Relic.
    Name string
    The workload's name.
    Permalink string
    The URL of the workload.
    ScopeAccountIds List<string>
    A list of account IDs that will be used to get entities from.
    StatusConfigAlertPolicy Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAlertPolicy
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    StatusConfigAutomatic Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomatic
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    StatusConfigStatic Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigStatic
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    WorkloadId string
    The unique entity identifier of the workload.
    AccountId string
    The New Relic account ID where you want to create the workload.
    CompositeEntitySearchQuery string
    The composite query used to compose a dynamic workload.
    Description string
    Relevant information about the workload.
    DynamicFlows []WorkloadDynamicFlowArgs
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    EntityGuids []string
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    EntitySearchQueries []WorkloadEntitySearchQueryArgs
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    Guid string
    The unique entity identifier of the workload in New Relic.
    Name string
    The workload's name.
    Permalink string
    The URL of the workload.
    ScopeAccountIds []string
    A list of account IDs that will be used to get entities from.
    StatusConfigAlertPolicy WorkloadStatusConfigAlertPolicyArgs
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    StatusConfigAutomatic WorkloadStatusConfigAutomaticArgs
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    StatusConfigStatic WorkloadStatusConfigStaticArgs
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    WorkloadId string
    The unique entity identifier of the workload.
    account_id string
    The New Relic account ID where you want to create the workload.
    composite_entity_search_query string
    The composite query used to compose a dynamic workload.
    description string
    Relevant information about the workload.
    dynamic_flows list(object)
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entity_guids list(string)
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entity_search_queries list(object)
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    guid string
    The unique entity identifier of the workload in New Relic.
    name string
    The workload's name.
    permalink string
    The URL of the workload.
    scope_account_ids list(string)
    A list of account IDs that will be used to get entities from.
    status_config_alert_policy object
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    status_config_automatic object
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    status_config_static object
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    workload_id string
    The unique entity identifier of the workload.
    accountId String
    The New Relic account ID where you want to create the workload.
    compositeEntitySearchQuery String
    The composite query used to compose a dynamic workload.
    description String
    Relevant information about the workload.
    dynamicFlows List<WorkloadDynamicFlow>
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entityGuids List<String>
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entitySearchQueries List<WorkloadEntitySearchQuery>
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    guid String
    The unique entity identifier of the workload in New Relic.
    name String
    The workload's name.
    permalink String
    The URL of the workload.
    scopeAccountIds List<String>
    A list of account IDs that will be used to get entities from.
    statusConfigAlertPolicy WorkloadStatusConfigAlertPolicy
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    statusConfigAutomatic WorkloadStatusConfigAutomatic
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    statusConfigStatic WorkloadStatusConfigStatic
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    workloadId String
    The unique entity identifier of the workload.
    accountId string
    The New Relic account ID where you want to create the workload.
    compositeEntitySearchQuery string
    The composite query used to compose a dynamic workload.
    description string
    Relevant information about the workload.
    dynamicFlows WorkloadDynamicFlow[]
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entityGuids string[]
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entitySearchQueries WorkloadEntitySearchQuery[]
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    guid string
    The unique entity identifier of the workload in New Relic.
    name string
    The workload's name.
    permalink string
    The URL of the workload.
    scopeAccountIds string[]
    A list of account IDs that will be used to get entities from.
    statusConfigAlertPolicy WorkloadStatusConfigAlertPolicy
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    statusConfigAutomatic WorkloadStatusConfigAutomatic
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    statusConfigStatic WorkloadStatusConfigStatic
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    workloadId string
    The unique entity identifier of the workload.
    account_id str
    The New Relic account ID where you want to create the workload.
    composite_entity_search_query str
    The composite query used to compose a dynamic workload.
    description str
    Relevant information about the workload.
    dynamic_flows Sequence[WorkloadDynamicFlowArgs]
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entity_guids Sequence[str]
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entity_search_queries Sequence[WorkloadEntitySearchQueryArgs]
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    guid str
    The unique entity identifier of the workload in New Relic.
    name str
    The workload's name.
    permalink str
    The URL of the workload.
    scope_account_ids Sequence[str]
    A list of account IDs that will be used to get entities from.
    status_config_alert_policy WorkloadStatusConfigAlertPolicyArgs
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    status_config_automatic WorkloadStatusConfigAutomaticArgs
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    status_config_static WorkloadStatusConfigStaticArgs
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    workload_id str
    The unique entity identifier of the workload.
    accountId String
    The New Relic account ID where you want to create the workload.
    compositeEntitySearchQuery String
    The composite query used to compose a dynamic workload.
    description String
    Relevant information about the workload.
    dynamicFlows List<Property Map>
    A list of dynamic flow entries that define an intelligent workload. If it is set alongside entityGuids or entitySearchQuery, dynamicFlows takes precedence and an intelligent workload is created. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested dynamicFlows blocks below for details.
    entityGuids List<String>
    A list of entity GUIDs manually assigned to this workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified.
    entitySearchQueries List<Property Map>
    A list of search queries that define a dynamic workload. At least one of entityGuids, entitySearchQuery, or dynamicFlows must be specified. See Nested entitySearchQuery blocks below for details.
    guid String
    The unique entity identifier of the workload in New Relic.
    name String
    The workload's name.
    permalink String
    The URL of the workload.
    scopeAccountIds List<String>
    A list of account IDs that will be used to get entities from.
    statusConfigAlertPolicy Property Map
    An alert policy status configuration for intelligent workloads. Requires dynamicFlows to be set. See Nested statusConfigAlertPolicy blocks below for details.
    statusConfigAutomatic Property Map
    An input object used to represent an automatic status configuration. See Nested statusConfigAutomatic blocks below for details.
    statusConfigStatic Property Map
    A list of static status configurations. You can only configure one static status for a workload. See Nested statusConfigStatic blocks below for details.
    workloadId String
    The unique entity identifier of the workload.

    Supporting Types

    WorkloadDynamicFlow, WorkloadDynamicFlowArgs

    EntityGuid string
    The unique entity identifier of the dynamic flow entry.
    TransactionName string
    The transaction name associated with the dynamic flow entry.
    EntityGuid string
    The unique entity identifier of the dynamic flow entry.
    TransactionName string
    The transaction name associated with the dynamic flow entry.
    entity_guid string
    The unique entity identifier of the dynamic flow entry.
    transaction_name string
    The transaction name associated with the dynamic flow entry.
    entityGuid String
    The unique entity identifier of the dynamic flow entry.
    transactionName String
    The transaction name associated with the dynamic flow entry.
    entityGuid string
    The unique entity identifier of the dynamic flow entry.
    transactionName string
    The transaction name associated with the dynamic flow entry.
    entity_guid str
    The unique entity identifier of the dynamic flow entry.
    transaction_name str
    The transaction name associated with the dynamic flow entry.
    entityGuid String
    The unique entity identifier of the dynamic flow entry.
    transactionName String
    The transaction name associated with the dynamic flow entry.

    WorkloadEntitySearchQuery, WorkloadEntitySearchQueryArgs

    Query string
    A valid entity search query; empty, and null values are considered invalid.
    Query string
    A valid entity search query; empty, and null values are considered invalid.
    query string
    A valid entity search query; empty, and null values are considered invalid.
    query String
    A valid entity search query; empty, and null values are considered invalid.
    query string
    A valid entity search query; empty, and null values are considered invalid.
    query str
    A valid entity search query; empty, and null values are considered invalid.
    query String
    A valid entity search query; empty, and null values are considered invalid.

    WorkloadStatusConfigAlertPolicy, WorkloadStatusConfigAlertPolicyArgs

    Enabled bool
    Whether the alert policy status configuration is enabled or not.
    Enabled bool
    Whether the alert policy status configuration is enabled or not.
    enabled bool
    Whether the alert policy status configuration is enabled or not.
    enabled Boolean
    Whether the alert policy status configuration is enabled or not.
    enabled boolean
    Whether the alert policy status configuration is enabled or not.
    enabled bool
    Whether the alert policy status configuration is enabled or not.
    enabled Boolean
    Whether the alert policy status configuration is enabled or not.

    WorkloadStatusConfigAutomatic, WorkloadStatusConfigAutomaticArgs

    Enabled bool
    Whether the automatic status configuration is enabled or not.
    RemainingEntitiesRule Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRemainingEntitiesRule
    An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
    Rules List<Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRule>
    A list of rules.
    Enabled bool
    Whether the automatic status configuration is enabled or not.
    RemainingEntitiesRule WorkloadStatusConfigAutomaticRemainingEntitiesRule
    An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
    Rules []WorkloadStatusConfigAutomaticRule
    A list of rules.
    enabled bool
    Whether the automatic status configuration is enabled or not.
    remaining_entities_rule object
    An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
    rules list(object)
    A list of rules.
    enabled Boolean
    Whether the automatic status configuration is enabled or not.
    remainingEntitiesRule WorkloadStatusConfigAutomaticRemainingEntitiesRule
    An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
    rules List<WorkloadStatusConfigAutomaticRule>
    A list of rules.
    enabled boolean
    Whether the automatic status configuration is enabled or not.
    remainingEntitiesRule WorkloadStatusConfigAutomaticRemainingEntitiesRule
    An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
    rules WorkloadStatusConfigAutomaticRule[]
    A list of rules.
    enabled bool
    Whether the automatic status configuration is enabled or not.
    remaining_entities_rule WorkloadStatusConfigAutomaticRemainingEntitiesRule
    An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
    rules Sequence[WorkloadStatusConfigAutomaticRule]
    A list of rules.
    enabled Boolean
    Whether the automatic status configuration is enabled or not.
    remainingEntitiesRule Property Map
    An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
    rules List<Property Map>
    A list of rules.

    WorkloadStatusConfigAutomaticRemainingEntitiesRule, WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs

    remaining_entities_rule_rollup object
    The input object used to represent a rollup strategy.
    remainingEntitiesRuleRollup Property Map
    The input object used to represent a rollup strategy.

    WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollup, WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs

    GroupBy string
    The grouping to be applied to the remaining entities.
    Strategy string
    The rollup strategy that is applied to a group of entities.
    ThresholdType string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    ThresholdValue int
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    GroupBy string
    The grouping to be applied to the remaining entities.
    Strategy string
    The rollup strategy that is applied to a group of entities.
    ThresholdType string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    ThresholdValue int
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    group_by string
    The grouping to be applied to the remaining entities.
    strategy string
    The rollup strategy that is applied to a group of entities.
    threshold_type string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    threshold_value number
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    groupBy String
    The grouping to be applied to the remaining entities.
    strategy String
    The rollup strategy that is applied to a group of entities.
    thresholdType String
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    thresholdValue Integer
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    groupBy string
    The grouping to be applied to the remaining entities.
    strategy string
    The rollup strategy that is applied to a group of entities.
    thresholdType string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    thresholdValue number
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    group_by str
    The grouping to be applied to the remaining entities.
    strategy str
    The rollup strategy that is applied to a group of entities.
    threshold_type str
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    threshold_value int
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    groupBy String
    The grouping to be applied to the remaining entities.
    strategy String
    The rollup strategy that is applied to a group of entities.
    thresholdType String
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    thresholdValue Number
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.

    WorkloadStatusConfigAutomaticRule, WorkloadStatusConfigAutomaticRuleArgs

    Rollup Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleRollup
    The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
    EntityGuids List<string>
    A list of entity GUIDs composing the rule. At least one of entityGuids or nrqlQuery must be defined.
    NrqlQueries List<Pulumi.NewRelic.Plugins.Inputs.WorkloadStatusConfigAutomaticRuleNrqlQuery>
    A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrqlQuery blocks below for details. At least one of entityGuids or nrqlQuery must be defined.
    Rollup WorkloadStatusConfigAutomaticRuleRollup
    The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
    EntityGuids []string
    A list of entity GUIDs composing the rule. At least one of entityGuids or nrqlQuery must be defined.
    NrqlQueries []WorkloadStatusConfigAutomaticRuleNrqlQuery
    A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrqlQuery blocks below for details. At least one of entityGuids or nrqlQuery must be defined.
    rollup object
    The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
    entity_guids list(string)
    A list of entity GUIDs composing the rule. At least one of entityGuids or nrqlQuery must be defined.
    nrql_queries list(object)
    A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrqlQuery blocks below for details. At least one of entityGuids or nrqlQuery must be defined.
    rollup WorkloadStatusConfigAutomaticRuleRollup
    The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
    entityGuids List<String>
    A list of entity GUIDs composing the rule. At least one of entityGuids or nrqlQuery must be defined.
    nrqlQueries List<WorkloadStatusConfigAutomaticRuleNrqlQuery>
    A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrqlQuery blocks below for details. At least one of entityGuids or nrqlQuery must be defined.
    rollup WorkloadStatusConfigAutomaticRuleRollup
    The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
    entityGuids string[]
    A list of entity GUIDs composing the rule. At least one of entityGuids or nrqlQuery must be defined.
    nrqlQueries WorkloadStatusConfigAutomaticRuleNrqlQuery[]
    A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrqlQuery blocks below for details. At least one of entityGuids or nrqlQuery must be defined.
    rollup WorkloadStatusConfigAutomaticRuleRollup
    The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
    entity_guids Sequence[str]
    A list of entity GUIDs composing the rule. At least one of entityGuids or nrqlQuery must be defined.
    nrql_queries Sequence[WorkloadStatusConfigAutomaticRuleNrqlQuery]
    A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrqlQuery blocks below for details. At least one of entityGuids or nrqlQuery must be defined.
    rollup Property Map
    The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
    entityGuids List<String>
    A list of entity GUIDs composing the rule. At least one of entityGuids or nrqlQuery must be defined.
    nrqlQueries List<Property Map>
    A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrqlQuery blocks below for details. At least one of entityGuids or nrqlQuery must be defined.

    WorkloadStatusConfigAutomaticRuleNrqlQuery, WorkloadStatusConfigAutomaticRuleNrqlQueryArgs

    Query string
    The entity search query that is used to perform the search of a group of entities.
    Query string
    The entity search query that is used to perform the search of a group of entities.
    query string
    The entity search query that is used to perform the search of a group of entities.
    query String
    The entity search query that is used to perform the search of a group of entities.
    query string
    The entity search query that is used to perform the search of a group of entities.
    query str
    The entity search query that is used to perform the search of a group of entities.
    query String
    The entity search query that is used to perform the search of a group of entities.

    WorkloadStatusConfigAutomaticRuleRollup, WorkloadStatusConfigAutomaticRuleRollupArgs

    Strategy string
    The rollup strategy that is applied to a group of entities.
    ThresholdType string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    ThresholdValue int
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    Strategy string
    The rollup strategy that is applied to a group of entities.
    ThresholdType string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    ThresholdValue int
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    strategy string
    The rollup strategy that is applied to a group of entities.
    threshold_type string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    threshold_value number
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    strategy String
    The rollup strategy that is applied to a group of entities.
    thresholdType String
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    thresholdValue Integer
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    strategy string
    The rollup strategy that is applied to a group of entities.
    thresholdType string
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    thresholdValue number
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    strategy str
    The rollup strategy that is applied to a group of entities.
    threshold_type str
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    threshold_value int
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
    strategy String
    The rollup strategy that is applied to a group of entities.
    thresholdType String
    Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
    thresholdValue Number
    Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.

    WorkloadStatusConfigStatic, WorkloadStatusConfigStaticArgs

    Enabled bool
    Whether the static status configuration is enabled or not.
    Status string
    The status of the workload.
    Description string
    Relevant information about the workload.
    Summary string
    A short description of the status of the workload.
    Enabled bool
    Whether the static status configuration is enabled or not.
    Status string
    The status of the workload.
    Description string
    Relevant information about the workload.
    Summary string
    A short description of the status of the workload.
    enabled bool
    Whether the static status configuration is enabled or not.
    status string
    The status of the workload.
    description string
    Relevant information about the workload.
    summary string
    A short description of the status of the workload.
    enabled Boolean
    Whether the static status configuration is enabled or not.
    status String
    The status of the workload.
    description String
    Relevant information about the workload.
    summary String
    A short description of the status of the workload.
    enabled boolean
    Whether the static status configuration is enabled or not.
    status string
    The status of the workload.
    description string
    Relevant information about the workload.
    summary string
    A short description of the status of the workload.
    enabled bool
    Whether the static status configuration is enabled or not.
    status str
    The status of the workload.
    description str
    Relevant information about the workload.
    summary str
    A short description of the status of the workload.
    enabled Boolean
    Whether the static status configuration is enabled or not.
    status String
    The status of the workload.
    description String
    Relevant information about the workload.
    summary String
    A short description of the status of the workload.

    Import

    New Relic workloads can be imported using a concatenated string of the format <account_id>:<workload_id>:<guid>, e.g.

    $ pulumi import newrelic:plugins/workload:Workload foo 12345678:1456:MjUyMDUyOHxBUE18QVBRTElDQVRJT058MjE1MDM3Nzk1

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    New Relic pulumi/pulumi-newrelic
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the newrelic Terraform Provider.
    newrelic logo
    Viewing docs for New Relic v5.73.0
    published on Wednesday, Jul 1, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-newrelic

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial