pulumi-newrelic 5.19.0a1708333884__py3-none-any.whl → 5.20.0__py3-none-any.whl

pulumi_newrelic/__init__.py

@@ -23,12 +23,14 @@ from .get_application import *
 from .get_authentication_domain import *
 from .get_cloud_account import *
 from .get_entity import *
+from .get_group import *
 from .get_key_transaction import *
 from .get_notification_destination import *
 from .get_obfuscation_expression import *
 from .get_service_level_alert_helper import *
 from .get_test_grok_pattern import *
 from .get_user import *
+from .group import *
 from .infra_alert_condition import *
 from .log_parsing_rule import *
 from .monitor_downtime import *
@@ -222,6 +224,14 @@ _utilities.register(
    "newrelic:index/eventsToMetricsRule:EventsToMetricsRule": "EventsToMetricsRule"
   }
  },
+ {
+  "pkg": "newrelic",
+  "mod": "index/group",
+  "fqn": "pulumi_newrelic",
+  "classes": {
+   "newrelic:index/group:Group": "Group"
+  }
+ },
  {
   "pkg": "newrelic",
   "mod": "index/infraAlertCondition",

pulumi_newrelic/alert_policy.py

@@ -191,6 +191,18 @@ class AlertPolicy(pulumi.CustomResource):
         ```
         ### Provision multiple notification channels and add those channels to a policy
 
+        The following arguments are supported:
+
+          * `name` - (Required) The name of the policy.
+          * `incident_preference` - (Optional) The rollup strategy for the policy, which can have one of the following values (the default value is `PER_POLICY`):
+            * `PER_POLICY` - This sets the incident grouping preference of the policy to **One issue per policy**. Refer to [this page](https://docs.newrelic.com/docs/alerts-applied-intelligence/new-relic-alerts/alert-policies/specify-when-alerts-create-incidents/#preference-policy) for more details on this incident grouping preference.
+            * `PER_CONDITION` - This sets the incident grouping preference of the policy to **One issue per condition**. Refer to [this page](https://docs.newrelic.com/docs/alerts-applied-intelligence/new-relic-alerts/alert-policies/specify-when-alerts-create-incidents/#preference-condition) for more details on this incident grouping preference.
+            * `PER_CONDITION_AND_TARGET` - This sets the incident grouping preference of the policy to **One issue per condition and signal**. Refer to [this page](https://docs.newrelic.com/docs/alerts-applied-intelligence/new-relic-alerts/alert-policies/specify-when-alerts-create-incidents/#preference-signal) for more details on this incident grouping preference.
+          * `channel_ids` - (Optional) **DEPRECATED** The `channel_ids` argument is deprecated and will be removed in the next major release of the provider. An array of channel IDs (integers) to assign to the policy. Adding or removing channel IDs from this array will result in a new alert policy resource being created and the old one being destroyed. Also note that channel IDs _cannot_ be imported via `pulumi import` (see Import for info).
+          * `account_id` - (Optional) The New Relic account ID to operate on.  This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
+        ## Additional Examples
+
+        ##### Provision multiple notification channels and add those channels to a policy
         ```python
         import pulumi
         import pulumi_newrelic as newrelic
@@ -217,6 +229,7 @@ class AlertPolicy(pulumi.CustomResource):
                 email_channel.id,
             ])
         ```
+
         ### Reference existing notification channels and add those channel to a policy
         ```python
         import pulumi
@@ -271,6 +284,18 @@ class AlertPolicy(pulumi.CustomResource):
         ```
         ### Provision multiple notification channels and add those channels to a policy
 
+        The following arguments are supported:
+
+          * `name` - (Required) The name of the policy.
+          * `incident_preference` - (Optional) The rollup strategy for the policy, which can have one of the following values (the default value is `PER_POLICY`):
+            * `PER_POLICY` - This sets the incident grouping preference of the policy to **One issue per policy**. Refer to [this page](https://docs.newrelic.com/docs/alerts-applied-intelligence/new-relic-alerts/alert-policies/specify-when-alerts-create-incidents/#preference-policy) for more details on this incident grouping preference.
+            * `PER_CONDITION` - This sets the incident grouping preference of the policy to **One issue per condition**. Refer to [this page](https://docs.newrelic.com/docs/alerts-applied-intelligence/new-relic-alerts/alert-policies/specify-when-alerts-create-incidents/#preference-condition) for more details on this incident grouping preference.
+            * `PER_CONDITION_AND_TARGET` - This sets the incident grouping preference of the policy to **One issue per condition and signal**. Refer to [this page](https://docs.newrelic.com/docs/alerts-applied-intelligence/new-relic-alerts/alert-policies/specify-when-alerts-create-incidents/#preference-signal) for more details on this incident grouping preference.
+          * `channel_ids` - (Optional) **DEPRECATED** The `channel_ids` argument is deprecated and will be removed in the next major release of the provider. An array of channel IDs (integers) to assign to the policy. Adding or removing channel IDs from this array will result in a new alert policy resource being created and the old one being destroyed. Also note that channel IDs _cannot_ be imported via `pulumi import` (see Import for info).
+          * `account_id` - (Optional) The New Relic account ID to operate on.  This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
+        ## Additional Examples
+
+        ##### Provision multiple notification channels and add those channels to a policy
         ```python
         import pulumi
         import pulumi_newrelic as newrelic
@@ -297,6 +322,7 @@ class AlertPolicy(pulumi.CustomResource):
                 email_channel.id,
             ])
         ```
+
         ### Reference existing notification channels and add those channel to a policy
         ```python
         import pulumi

pulumi_newrelic/get_alert_policy.py

@@ -66,7 +66,7 @@ class GetAlertPolicyResult:
     @pulumi.getter(name="incidentPreference")
     def incident_preference(self) -> Optional[str]:
         """
-        The rollup strategy for the policy. Options include: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET. The default is PER_POLICY.
+        The rollup strategy for the policy, which can have one of the following values:
         """
         return pulumi.get(self, "incident_preference")
 
@@ -107,7 +107,7 @@ def get_alert_policy(account_id: Optional[int] = None,
 
 
     :param int account_id: The New Relic account ID to operate on.  This allows you to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
-    :param str incident_preference: The rollup strategy for the policy. Options include: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET. The default is PER_POLICY.
+    :param str incident_preference: The rollup strategy for the policy, which can have one of the following values:
     :param str name: The name of the alert policy in New Relic.
     """
     __args__ = dict()
@@ -136,7 +136,7 @@ def get_alert_policy_output(account_id: Optional[pulumi.Input[Optional[int]]] =
 
 
     :param int account_id: The New Relic account ID to operate on.  This allows you to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
-    :param str incident_preference: The rollup strategy for the policy. Options include: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET. The default is PER_POLICY.
+    :param str incident_preference: The rollup strategy for the policy, which can have one of the following values:
     :param str name: The name of the alert policy in New Relic.
     """
     ...

pulumi_newrelic/get_group.py

@@ -0,0 +1,141 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from . import _utilities
+
+__all__ = [
+    'GetGroupResult',
+    'AwaitableGetGroupResult',
+    'get_group',
+    'get_group_output',
+]
+
+@pulumi.output_type
+class GetGroupResult:
+    """
+    A collection of values returned by getGroup.
+    """
+    def __init__(__self__, authentication_domain_id=None, id=None, name=None, user_ids=None):
+        if authentication_domain_id and not isinstance(authentication_domain_id, str):
+            raise TypeError("Expected argument 'authentication_domain_id' to be a str")
+        pulumi.set(__self__, "authentication_domain_id", authentication_domain_id)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if user_ids and not isinstance(user_ids, list):
+            raise TypeError("Expected argument 'user_ids' to be a list")
+        pulumi.set(__self__, "user_ids", user_ids)
+
+    @property
+    @pulumi.getter(name="authenticationDomainId")
+    def authentication_domain_id(self) -> str:
+        return pulumi.get(self, "authentication_domain_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ID of the fetched matching group.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="userIds")
+    def user_ids(self) -> Sequence[str]:
+        """
+        IDs of users who belong to the group. In the absence of any users in the group, the value of this attribute would be an empty list.
+        """
+        return pulumi.get(self, "user_ids")
+
+
+class AwaitableGetGroupResult(GetGroupResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetGroupResult(
+            authentication_domain_id=self.authentication_domain_id,
+            id=self.id,
+            name=self.name,
+            user_ids=self.user_ids)
+
+
+def get_group(authentication_domain_id: Optional[str] = None,
+              name: Optional[str] = None,
+              opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGroupResult:
+    """
+    The `Group` data source helps search for a group by its name and retrieve the ID of the matching group and other associated attributes.
+
+    ## Example Usage
+
+    The below example illustrates fetching the ID of a group (and IDs of users who belong to the group, if any) using the required arguments.
+
+    ```python
+    import pulumi
+    import pulumi_newrelic as newrelic
+
+    foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    foo_group = newrelic.get_group(authentication_domain_id=foo_authentication_domain.id,
+        name="Test Group")
+    ```
+
+
+    :param str authentication_domain_id: The ID of the authentication domain the group to be searched for belongs to.
+    :param str name: The name of the group to search for.
+           
+           > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+    """
+    __args__ = dict()
+    __args__['authenticationDomainId'] = authentication_domain_id
+    __args__['name'] = name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('newrelic:index/getGroup:getGroup', __args__, opts=opts, typ=GetGroupResult).value
+
+    return AwaitableGetGroupResult(
+        authentication_domain_id=pulumi.get(__ret__, 'authentication_domain_id'),
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'),
+        user_ids=pulumi.get(__ret__, 'user_ids'))
+
+
+@_utilities.lift_output_func(get_group)
+def get_group_output(authentication_domain_id: Optional[pulumi.Input[str]] = None,
+                     name: Optional[pulumi.Input[str]] = None,
+                     opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetGroupResult]:
+    """
+    The `Group` data source helps search for a group by its name and retrieve the ID of the matching group and other associated attributes.
+
+    ## Example Usage
+
+    The below example illustrates fetching the ID of a group (and IDs of users who belong to the group, if any) using the required arguments.
+
+    ```python
+    import pulumi
+    import pulumi_newrelic as newrelic
+
+    foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    foo_group = newrelic.get_group(authentication_domain_id=foo_authentication_domain.id,
+        name="Test Group")
+    ```
+
+
+    :param str authentication_domain_id: The ID of the authentication domain the group to be searched for belongs to.
+    :param str name: The name of the group to search for.
+           
+           > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+    """
+    ...

pulumi_newrelic/get_user.py

@@ -76,11 +76,11 @@ def get_user(authentication_domain_id: Optional[str] = None,
              name: Optional[str] = None,
              opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetUserResult:
     """
-    The `User` data source may be used to search for a user by their name and/or email ID, and accordingly, fetch the ID of the matching user.
+    The `User` data source helps search for a user by their name and/or email ID, and accordingly, fetch the ID of the matching user.
 
     ## Example Usage
 
-    The below example illustrates fetching a user's ID (and other arguments) using the ID of the authentication domain the user belongs to, as well as a name and/or email ID, which can be used as criteria to search for a user who matches these specified parameters.
+    The below example illustrates fetching a the ID of a user (and other arguments) using the ID of the authentication domain the user belongs to, as well as a name and/or email ID, which can be used as criteria to search for a user who matches these specified parameters.
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
@@ -98,7 +98,7 @@ def get_user(authentication_domain_id: Optional[str] = None,
            
            It should be noted that either `name` or `email_id` must be specified in order to retrieve a matching user.
            
-           > **NOTE** If the specified `name` matches, or is contained in the names of multiple users in the account, the data source will return the first match from the list of all matching users retrieved from the API. However, when using the `email_id` argument as the search criterion, only the user with the specified email ID will be returned, as each user has a unique email ID and multiple users cannot have the same email ID.
+           > **NOTE** If the `name` specified in the configuration matches the names of multiple users in the account, the data source will return the first match from the list of all matching users retrieved from the API. However, when using the `email_id` argument as the search criterion, only the user with the specified email ID will be returned, as each user has a unique email ID and multiple users cannot have the same email ID.
            
            > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
     :param str name: The name of the user to search for.
@@ -123,11 +123,11 @@ def get_user_output(authentication_domain_id: Optional[pulumi.Input[str]] = None
                     name: Optional[pulumi.Input[Optional[str]]] = None,
                     opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetUserResult]:
     """
-    The `User` data source may be used to search for a user by their name and/or email ID, and accordingly, fetch the ID of the matching user.
+    The `User` data source helps search for a user by their name and/or email ID, and accordingly, fetch the ID of the matching user.
 
     ## Example Usage
 
-    The below example illustrates fetching a user's ID (and other arguments) using the ID of the authentication domain the user belongs to, as well as a name and/or email ID, which can be used as criteria to search for a user who matches these specified parameters.
+    The below example illustrates fetching a the ID of a user (and other arguments) using the ID of the authentication domain the user belongs to, as well as a name and/or email ID, which can be used as criteria to search for a user who matches these specified parameters.
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
@@ -145,7 +145,7 @@ def get_user_output(authentication_domain_id: Optional[pulumi.Input[str]] = None
            
            It should be noted that either `name` or `email_id` must be specified in order to retrieve a matching user.
            
-           > **NOTE** If the specified `name` matches, or is contained in the names of multiple users in the account, the data source will return the first match from the list of all matching users retrieved from the API. However, when using the `email_id` argument as the search criterion, only the user with the specified email ID will be returned, as each user has a unique email ID and multiple users cannot have the same email ID.
+           > **NOTE** If the `name` specified in the configuration matches the names of multiple users in the account, the data source will return the first match from the list of all matching users retrieved from the API. However, when using the `email_id` argument as the search criterion, only the user with the specified email ID will be returned, as each user has a unique email ID and multiple users cannot have the same email ID.
            
            > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
     :param str name: The name of the user to search for.

pulumi_newrelic/group.py

@@ -0,0 +1,412 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from . import _utilities
+
+__all__ = ['GroupArgs', 'Group']
+
+@pulumi.input_type
+class GroupArgs:
+    def __init__(__self__, *,
+                 authentication_domain_id: pulumi.Input[str],
+                 name: Optional[pulumi.Input[str]] = None,
+                 user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        The set of arguments for constructing a Group resource.
+        :param pulumi.Input[str] authentication_domain_id: The ID of the authentication domain to which the group to be created would belong.
+        :param pulumi.Input[str] name: The name of the group to be created.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] user_ids: A list of IDs of users to be included in the group to be created.
+               
+               > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+               
+               > **WARNING:** Changing the `authentication_domain_id` of a `Group` resource that has already been applied would result in a **replacement** of the resource – destruction of the existing resource, followed by the addition of a new resource with the specified configuration. This is due to the fact that updating the `authentication_domain_id` of an existing group is not supported.
+        """
+        pulumi.set(__self__, "authentication_domain_id", authentication_domain_id)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if user_ids is not None:
+            pulumi.set(__self__, "user_ids", user_ids)
+
+    @property
+    @pulumi.getter(name="authenticationDomainId")
+    def authentication_domain_id(self) -> pulumi.Input[str]:
+        """
+        The ID of the authentication domain to which the group to be created would belong.
+        """
+        return pulumi.get(self, "authentication_domain_id")
+
+    @authentication_domain_id.setter
+    def authentication_domain_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "authentication_domain_id", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the group to be created.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="userIds")
+    def user_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        A list of IDs of users to be included in the group to be created.
+
+        > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+
+        > **WARNING:** Changing the `authentication_domain_id` of a `Group` resource that has already been applied would result in a **replacement** of the resource – destruction of the existing resource, followed by the addition of a new resource with the specified configuration. This is due to the fact that updating the `authentication_domain_id` of an existing group is not supported.
+        """
+        return pulumi.get(self, "user_ids")
+
+    @user_ids.setter
+    def user_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "user_ids", value)
+
+
+@pulumi.input_type
+class _GroupState:
+    def __init__(__self__, *,
+                 authentication_domain_id: Optional[pulumi.Input[str]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Input properties used for looking up and filtering Group resources.
+        :param pulumi.Input[str] authentication_domain_id: The ID of the authentication domain to which the group to be created would belong.
+        :param pulumi.Input[str] name: The name of the group to be created.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] user_ids: A list of IDs of users to be included in the group to be created.
+               
+               > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+               
+               > **WARNING:** Changing the `authentication_domain_id` of a `Group` resource that has already been applied would result in a **replacement** of the resource – destruction of the existing resource, followed by the addition of a new resource with the specified configuration. This is due to the fact that updating the `authentication_domain_id` of an existing group is not supported.
+        """
+        if authentication_domain_id is not None:
+            pulumi.set(__self__, "authentication_domain_id", authentication_domain_id)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if user_ids is not None:
+            pulumi.set(__self__, "user_ids", user_ids)
+
+    @property
+    @pulumi.getter(name="authenticationDomainId")
+    def authentication_domain_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of the authentication domain to which the group to be created would belong.
+        """
+        return pulumi.get(self, "authentication_domain_id")
+
+    @authentication_domain_id.setter
+    def authentication_domain_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "authentication_domain_id", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the group to be created.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="userIds")
+    def user_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        A list of IDs of users to be included in the group to be created.
+
+        > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+
+        > **WARNING:** Changing the `authentication_domain_id` of a `Group` resource that has already been applied would result in a **replacement** of the resource – destruction of the existing resource, followed by the addition of a new resource with the specified configuration. This is due to the fact that updating the `authentication_domain_id` of an existing group is not supported.
+        """
+        return pulumi.get(self, "user_ids")
+
+    @user_ids.setter
+    def user_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "user_ids", value)
+
+
+class Group(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 authentication_domain_id: Optional[pulumi.Input[str]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 __props__=None):
+        """
+        The `Group` resource facilitates creating, updating, and deleting groups in New Relic, while also enabling the addition and removal of users from these groups.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_newrelic as newrelic
+
+        foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+        foo_group = newrelic.Group("fooGroup",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_ids=[
+                "0001112222",
+                "2221110000",
+            ])
+        ```
+        ## Additional Examples
+
+        ### Addition of New Users to a New Group
+
+        The following example illustrates the creation of a group using the `Group` resource, to which users created using the `User` resource are added.
+
+        ```python
+        import pulumi
+        import pulumi_newrelic as newrelic
+
+        foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+        foo_user = newrelic.User("fooUser",
+            email_id="test_user_one@test.com",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_type="CORE_USER_TIER")
+        bar = newrelic.User("bar",
+            email_id="test_user_two@test.com",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_type="BASIC_USER_TIER")
+        foo_group = newrelic.Group("fooGroup",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_ids=[
+                foo_user.id,
+                bar.id,
+            ])
+        ```
+
+        ### Addition of Existing Users to a New Group
+
+        The following example demonstrates the usage of the `Group` resource to create a group, wherein the `User` data source is employed to associate existing users with the newly formed group.
+
+        ```python
+        import pulumi
+        import pulumi_newrelic as newrelic
+
+        foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+        foo_user = newrelic.get_user(authentication_domain_id=foo_authentication_domain.id,
+            email_id="test_user_one@test.com")
+        bar = newrelic.get_user(authentication_domain_id=foo_authentication_domain.id,
+            name="Test User Two")
+        foo_group = newrelic.Group("fooGroup",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_ids=[
+                foo_user.id,
+                bar.id,
+            ])
+        ```
+
+        > **NOTE** Please note that the addition of users to groups is only possible when both the group and the users to be added to it belong to the _same authentication domain_. If the group being created and the users being added to it belong to different authentication domains, an error indicating `user not found` or an equivalent error will be thrown.
+
+        ## Import
+
+        A group can be imported using its ID. Example:
+
+        ```sh
+        $ pulumi import newrelic:index/group:Group foo <group_id>
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] authentication_domain_id: The ID of the authentication domain to which the group to be created would belong.
+        :param pulumi.Input[str] name: The name of the group to be created.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] user_ids: A list of IDs of users to be included in the group to be created.
+               
+               > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+               
+               > **WARNING:** Changing the `authentication_domain_id` of a `Group` resource that has already been applied would result in a **replacement** of the resource – destruction of the existing resource, followed by the addition of a new resource with the specified configuration. This is due to the fact that updating the `authentication_domain_id` of an existing group is not supported.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: GroupArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        The `Group` resource facilitates creating, updating, and deleting groups in New Relic, while also enabling the addition and removal of users from these groups.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_newrelic as newrelic
+
+        foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+        foo_group = newrelic.Group("fooGroup",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_ids=[
+                "0001112222",
+                "2221110000",
+            ])
+        ```
+        ## Additional Examples
+
+        ### Addition of New Users to a New Group
+
+        The following example illustrates the creation of a group using the `Group` resource, to which users created using the `User` resource are added.
+
+        ```python
+        import pulumi
+        import pulumi_newrelic as newrelic
+
+        foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+        foo_user = newrelic.User("fooUser",
+            email_id="test_user_one@test.com",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_type="CORE_USER_TIER")
+        bar = newrelic.User("bar",
+            email_id="test_user_two@test.com",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_type="BASIC_USER_TIER")
+        foo_group = newrelic.Group("fooGroup",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_ids=[
+                foo_user.id,
+                bar.id,
+            ])
+        ```
+
+        ### Addition of Existing Users to a New Group
+
+        The following example demonstrates the usage of the `Group` resource to create a group, wherein the `User` data source is employed to associate existing users with the newly formed group.
+
+        ```python
+        import pulumi
+        import pulumi_newrelic as newrelic
+
+        foo_authentication_domain = newrelic.get_authentication_domain(name="Test Authentication Domain")
+        foo_user = newrelic.get_user(authentication_domain_id=foo_authentication_domain.id,
+            email_id="test_user_one@test.com")
+        bar = newrelic.get_user(authentication_domain_id=foo_authentication_domain.id,
+            name="Test User Two")
+        foo_group = newrelic.Group("fooGroup",
+            authentication_domain_id=foo_authentication_domain.id,
+            user_ids=[
+                foo_user.id,
+                bar.id,
+            ])
+        ```
+
+        > **NOTE** Please note that the addition of users to groups is only possible when both the group and the users to be added to it belong to the _same authentication domain_. If the group being created and the users being added to it belong to different authentication domains, an error indicating `user not found` or an equivalent error will be thrown.
+
+        ## Import
+
+        A group can be imported using its ID. Example:
+
+        ```sh
+        $ pulumi import newrelic:index/group:Group foo <group_id>
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param GroupArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(GroupArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 authentication_domain_id: Optional[pulumi.Input[str]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = GroupArgs.__new__(GroupArgs)
+
+            if authentication_domain_id is None and not opts.urn:
+                raise TypeError("Missing required property 'authentication_domain_id'")
+            __props__.__dict__["authentication_domain_id"] = authentication_domain_id
+            __props__.__dict__["name"] = name
+            __props__.__dict__["user_ids"] = user_ids
+        super(Group, __self__).__init__(
+            'newrelic:index/group:Group',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            authentication_domain_id: Optional[pulumi.Input[str]] = None,
+            name: Optional[pulumi.Input[str]] = None,
+            user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'Group':
+        """
+        Get an existing Group resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] authentication_domain_id: The ID of the authentication domain to which the group to be created would belong.
+        :param pulumi.Input[str] name: The name of the group to be created.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] user_ids: A list of IDs of users to be included in the group to be created.
+               
+               > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+               
+               > **WARNING:** Changing the `authentication_domain_id` of a `Group` resource that has already been applied would result in a **replacement** of the resource – destruction of the existing resource, followed by the addition of a new resource with the specified configuration. This is due to the fact that updating the `authentication_domain_id` of an existing group is not supported.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _GroupState.__new__(_GroupState)
+
+        __props__.__dict__["authentication_domain_id"] = authentication_domain_id
+        __props__.__dict__["name"] = name
+        __props__.__dict__["user_ids"] = user_ids
+        return Group(resource_name, opts=opts, __props__=__props__)
+
+    @property
+    @pulumi.getter(name="authenticationDomainId")
+    def authentication_domain_id(self) -> pulumi.Output[str]:
+        """
+        The ID of the authentication domain to which the group to be created would belong.
+        """
+        return pulumi.get(self, "authentication_domain_id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Output[str]:
+        """
+        The name of the group to be created.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="userIds")
+    def user_ids(self) -> pulumi.Output[Optional[Sequence[str]]]:
+        """
+        A list of IDs of users to be included in the group to be created.
+
+        > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
+
+        > **WARNING:** Changing the `authentication_domain_id` of a `Group` resource that has already been applied would result in a **replacement** of the resource – destruction of the existing resource, followed by the addition of a new resource with the specified configuration. This is due to the fact that updating the `authentication_domain_id` of an existing group is not supported.
+        """
+        return pulumi.get(self, "user_ids")
+

pulumi_newrelic/notification_channel.py

@@ -398,6 +398,7 @@ class NotificationChannel(pulumi.CustomResource):
                 ),
                 newrelic.NotificationChannelPropertyArgs(
                     key="service",
+                    label="Service Name",
                     value="PTQK3FM",
                 ),
                 newrelic.NotificationChannelPropertyArgs(
@@ -565,6 +566,18 @@ class NotificationChannel(pulumi.CustomResource):
 
         > **NOTE:** `AlertChannel` are legacy resources.
 
+        ## Import
+
+        Channels can only be used by a single workflow, therefore importing them is not particularly useful, because in the UI channels are created upon workflow creation.
+
+         Additionally, the channel id isn't available via the UI, and you'd need to look it up with the `channels` query in the NerdGraph API.
+
+         That being said, importing is possible using -
+
+        ```sh
+        $ pulumi import newrelic:index/notificationChannel:NotificationChannel foo <destination_id>
+        ```
+
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[int] account_id: Determines the New Relic account where the notification channel will be created. Defaults to the account associated with the API key used.
@@ -701,6 +714,7 @@ class NotificationChannel(pulumi.CustomResource):
                 ),
                 newrelic.NotificationChannelPropertyArgs(
                     key="service",
+                    label="Service Name",
                     value="PTQK3FM",
                 ),
                 newrelic.NotificationChannelPropertyArgs(
@@ -868,6 +882,18 @@ class NotificationChannel(pulumi.CustomResource):
 
         > **NOTE:** `AlertChannel` are legacy resources.
 
+        ## Import
+
+        Channels can only be used by a single workflow, therefore importing them is not particularly useful, because in the UI channels are created upon workflow creation.
+
+         Additionally, the channel id isn't available via the UI, and you'd need to look it up with the `channels` query in the NerdGraph API.
+
+         That being said, importing is possible using -
+
+        ```sh
+        $ pulumi import newrelic:index/notificationChannel:NotificationChannel foo <destination_id>
+        ```
+
         :param str resource_name: The name of the resource.
         :param NotificationChannelArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.

pulumi_newrelic/notification_destination.py

@@ -301,7 +301,76 @@ class NotificationDestination(pulumi.CustomResource):
                  type: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
-        Create a NotificationDestination resource with the given unique name, props, and options.
+        ## Import
+
+        Destination id can be found in the Destinations page -> three dots at the right of the chosen destination -> copy destination id to clipboard.
+
+         This example is especially useful for slack destinations which *must* be imported.
+
+         1. Add an empty resource to your terraform file:
+
+         terraform
+
+         resource "newrelic_notification_destination" "foo" {
+
+         }
+
+        ```sh
+        $ pulumi import newrelic:index/notificationDestination:NotificationDestination
+
+        Run import command: `newrelic_notification_destination.foo <destination_id>`
+        ```
+
+         3. Run the following command after the import successfully done and copy the information to your resource:
+
+         `terraform state show newrelic_notification_destination.foo`
+
+         4. Add `ignore_changes` attribute on `auth_token` in your imported resource:
+
+         terraform
+
+         lifecycle {
+
+         ignore_changes = [auth_token]
+
+         }
+
+         Your imported destination should look like that:
+
+         terraform
+
+         resource "newrelic_notification_destination" "foo" {
+
+         lifecycle {
+
+         ignore_changes = [auth_token]
+
+         }
+
+         name = "*********"
+
+         type = "SLACK"
+
+         auth_token {
+
+         prefix = "Bearer"
+
+         }
+
+         property {
+
+         key
+
+         = "teamName"
+
+         label = "Team Name"
+
+         value = "******"
+
+         }
+
+         }
+
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[int] account_id: Determines the New Relic account where the notification destination will be created. Defaults to the account associated with the API key used.
@@ -320,7 +389,76 @@ class NotificationDestination(pulumi.CustomResource):
                  args: NotificationDestinationArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Create a NotificationDestination resource with the given unique name, props, and options.
+        ## Import
+
+        Destination id can be found in the Destinations page -> three dots at the right of the chosen destination -> copy destination id to clipboard.
+
+         This example is especially useful for slack destinations which *must* be imported.
+
+         1. Add an empty resource to your terraform file:
+
+         terraform
+
+         resource "newrelic_notification_destination" "foo" {
+
+         }
+
+        ```sh
+        $ pulumi import newrelic:index/notificationDestination:NotificationDestination
+
+        Run import command: `newrelic_notification_destination.foo <destination_id>`
+        ```
+
+         3. Run the following command after the import successfully done and copy the information to your resource:
+
+         `terraform state show newrelic_notification_destination.foo`
+
+         4. Add `ignore_changes` attribute on `auth_token` in your imported resource:
+
+         terraform
+
+         lifecycle {
+
+         ignore_changes = [auth_token]
+
+         }
+
+         Your imported destination should look like that:
+
+         terraform
+
+         resource "newrelic_notification_destination" "foo" {
+
+         lifecycle {
+
+         ignore_changes = [auth_token]
+
+         }
+
+         name = "*********"
+
+         type = "SLACK"
+
+         auth_token {
+
+         prefix = "Bearer"
+
+         }
+
+         property {
+
+         key
+
+         = "teamName"
+
+         label = "Team Name"
+
+         value = "******"
+
+         }
+
+         }
+
         :param str resource_name: The name of the resource.
         :param NotificationDestinationArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.

{pulumi_newrelic-5.19.0a1708333884.dist-info → pulumi_newrelic-5.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi_newrelic
-Version: 5.19.0a1708333884
+Version: 5.20.0
 Summary: A Pulumi package for creating and managing New Relic resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_newrelic-5.19.0a1708333884.dist-info → pulumi_newrelic-5.20.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-pulumi_newrelic/__init__.py,sha256=DeKBeJx_1XmXPvkHLKtqXOh4AG3cdgTNDr3LGgGv9vE,11142
+pulumi_newrelic/__init__.py,sha256=Ekxa_c_Z6YcPWbvb7FFvd3lBPGRctMTA9rQGGzd13Ts,11328
 pulumi_newrelic/_inputs.py,sha256=IK3QSgzencxOTb3L-iSDvdaEvKORUTKYewvS8c5VeA8,476794
 pulumi_newrelic/_utilities.py,sha256=b6gJn0IIeM1t6Q7EVjqw3yhuGyP-uENQhtL5yp7aHR8,9248
 pulumi_newrelic/account_management.py,sha256=auMjKSSMQg57OSvOxBJ3MmN_E5z4LdwM4OAwm5AMD2k,8691
 pulumi_newrelic/alert_channel.py,sha256=f0nLOEtmxakqQPeevuE9W4Sd0pch2RQnfP4sCWApI30,20890
 pulumi_newrelic/alert_condition.py,sha256=X_2UfWFTWd7PJpmfRGSbgpX4eW1NmPoqtYNFfyR5U1o,45746
 pulumi_newrelic/alert_muting_rule.py,sha256=nGTdLpOM2fk_wOEMWZLIZokEsMvnbJVH2Mm3Tu1qnHY,19077
-pulumi_newrelic/alert_policy.py,sha256=qaIWag4jIrzO4dk-pJYO2iQI8Mqp5RtSCeNk79JvcGo,21883
+pulumi_newrelic/alert_policy.py,sha256=sBu7RkF3LVU2jSmtPHCluS3vzFbxxLV8VCtCtS3VYe4,26105
 pulumi_newrelic/alert_policy_channel.py,sha256=-r72F1aLGwZcTFuTW68zz-pT497t7bojR_lpHOYJngI,15047
 pulumi_newrelic/api_access_key.py,sha256=qxHUn8uyGbDNjxVa8Rf9PGKKe63iIlGR0SGD-2Dtdlg,22003
 pulumi_newrelic/browser_application.py,sha256=pcN5YzkCDoHQFZImpDVQn875rou2vZb54Q9x2W6jles,20501
@@ -14,22 +14,24 @@ pulumi_newrelic/entity_tags.py,sha256=xFxM971c5_blXqlqvK5rsZzYZlDo_4iBIEitMxpn0T
 pulumi_newrelic/events_to_metrics_rule.py,sha256=NGNxYo4jxww9nXRSwlvqL1B-WdJHGWa64Xa_xcEccro,15888
 pulumi_newrelic/get_account.py,sha256=9UzKNb5Jjy97owe2HwcNx-fsUxPEel_V3anKifTC5Vo,4651
 pulumi_newrelic/get_alert_channel.py,sha256=8fbAqBFL5BEXRWqTEf1RjfMnF_faYb59-ZiSf0R4-wk,5416
-pulumi_newrelic/get_alert_policy.py,sha256=SrLWQw7kXrSWjh_GeNd4d1axOuCkfxD6faKENLMRpck,5963
+pulumi_newrelic/get_alert_policy.py,sha256=bXG0H6FGgPJOlSif9jcX3C281YSH7RdQLUMMeTzDhks,5795
 pulumi_newrelic/get_application.py,sha256=5ABKpvWzERwjIEsWwQDpeP3ZJba4shmYuyiNxKvHpnc,5312
 pulumi_newrelic/get_authentication_domain.py,sha256=UmJnleWQupH_STEvT9v4rRQoS3xnACPkuauPlzmCdkY,3586
 pulumi_newrelic/get_cloud_account.py,sha256=8yAYziHYdHd1wIfNggdgI_wLq39amS3_f4eW-a-_hMY,5187
 pulumi_newrelic/get_entity.py,sha256=RNG2amzCxUcwWs3uBRyZL-je70lTzuwO-dpOqk9bpiU,10853
+pulumi_newrelic/get_group.py,sha256=p50E6SFqYdF4O7QeK5z0mqs1e06MYba2p-0BSHta89A,5663
 pulumi_newrelic/get_key_transaction.py,sha256=QOLqA1EZ4G6BxVQCSZt94rf0M9iJJwGwvW3ioSX71Y0,4081
 pulumi_newrelic/get_notification_destination.py,sha256=x13_HISLPz42t8MnE9QGf1QEhhc_WfDN3OE4Cx1wB8Q,6365
 pulumi_newrelic/get_obfuscation_expression.py,sha256=UUhLN7g-VnQ9ASzFt8M4-GE4EpWawIfoug8DJW0Mb_U,4867
 pulumi_newrelic/get_service_level_alert_helper.py,sha256=yOxb_74lGurxVmmMlVhR6qGy5chm2wkvpwW2eUDmipo,20140
 pulumi_newrelic/get_test_grok_pattern.py,sha256=Mxo8j32CyD6W_lGwk3BF_NnUA1mi9gfe9voa947HbtU,5504
-pulumi_newrelic/get_user.py,sha256=gmZfFPNr9S1ipkDfIhC-rnpMB0lTlpsBOjujDT-J17I,7286
+pulumi_newrelic/get_user.py,sha256=QxI7LiKvkiBOc-Ovj3ySFzD1l2SrGO1Y7-xnrGhfP3A,7284
+pulumi_newrelic/group.py,sha256=Moi1VJ82NTlIj0u25FEfnxTuNatpbTiC89GrUuCSbSY,21045
 pulumi_newrelic/infra_alert_condition.py,sha256=T2cW_J8mqiIReV9YNQT3KbNSU8_5GGvPrvpMzWiFYLU,56742
 pulumi_newrelic/log_parsing_rule.py,sha256=nlGKJssQ3d6gjNG1LJZjdYxfbidGHdy7bRbTqw-LKsY,22270
 pulumi_newrelic/monitor_downtime.py,sha256=qFGiikR2TMyGDjHn5t6vs9TKUz8Sdksd26rUKpvsUEE,45214
-pulumi_newrelic/notification_channel.py,sha256=_55p2WkYvHV-8I4ApZ1q7HW8y1CIBtkrLJFpB7pn-e4,43984
-pulumi_newrelic/notification_destination.py,sha256=ELFKkBpyc4ZzkYe64ZenFVM8lCgVXD8bQf2aYGdWRjA,25645
+pulumi_newrelic/notification_channel.py,sha256=Jb08kGYDUSVSlao2mG8HYAOexEs-xbYxKJGC6Chj7jw,45108
+pulumi_newrelic/notification_destination.py,sha256=4rdVen05b3UNVWkoRzSAelSSR9EWJtYlg6r9vl_U99A,28367
 pulumi_newrelic/nrql_alert_condition.py,sha256=HrmjCKrj21H2l0StdxlE0-OHGdSCUPIOdkYUXUDUtbQ,105561
 pulumi_newrelic/nrql_drop_rule.py,sha256=uOY6vN0Fqufl13vAUGHikXJLhKLeIRUYb-PB4vkh6nI,15726
 pulumi_newrelic/obfuscation_expression.py,sha256=Ug-pkNbylLLndFS-qEgt2ohs-s0YMY7fqhvqxx6p1to,12291
@@ -81,7 +83,7 @@ pulumi_newrelic/synthetics/private_location.py,sha256=x2Ji28435eqLVwZY9tXLN4QV08
 pulumi_newrelic/synthetics/script_monitor.py,sha256=4OQteFH88JhQnTC6j9GwBhXO-DYWarjGkkqX0WIEPeE,54582
 pulumi_newrelic/synthetics/secure_credential.py,sha256=O5SFzx3UNw64KjxCRzxatsXoPjT_e6VyJ32JTa0f0Dw,15604
 pulumi_newrelic/synthetics/step_monitor.py,sha256=SykPSAJYHcqMD9dNXSXx2cTpsKmF3cy6ObXNRqb2CTQ,35141
-pulumi_newrelic-5.19.0a1708333884.dist-info/METADATA,sha256=a7CBN_ATnUJp0Gmc2uZz0tXqdG8wvhIhIGlumOPaQrk,3900
-pulumi_newrelic-5.19.0a1708333884.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-pulumi_newrelic-5.19.0a1708333884.dist-info/top_level.txt,sha256=BjE1Wsu6Ah_A7k08uV5vRSZ2R_5uY3wFvSWJaa7ZoQk,16
-pulumi_newrelic-5.19.0a1708333884.dist-info/RECORD,,
+pulumi_newrelic-5.20.0.dist-info/METADATA,sha256=ZsUxsYnIKCllb5_CsHYdticIyFw3bE7WVsOeRXIbwjw,3889
+pulumi_newrelic-5.20.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+pulumi_newrelic-5.20.0.dist-info/top_level.txt,sha256=BjE1Wsu6Ah_A7k08uV5vRSZ2R_5uY3wFvSWJaa7ZoQk,16
+pulumi_newrelic-5.20.0.dist-info/RECORD,,