pulumi-newrelic 5.19.0a1708065288__tar.gz → 5.20.0__tar.gz

{pulumi_newrelic-5.19.0a1708065288 → pulumi_newrelic-5.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi_newrelic
-Version: 5.19.0a1708065288
+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.0a1708065288 → pulumi_newrelic-5.20.0}/pulumi_newrelic/__init__.py

@@ -23,11 +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 *
@@ -42,6 +45,7 @@ from .one_dashboard_json import *
 from .one_dashboard_raw import *
 from .provider import *
 from .service_level import *
+from .user import *
 from .workflow import *
 from ._inputs import *
 from . import outputs
@@ -220,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",
@@ -324,6 +336,14 @@ _utilities.register(
    "newrelic:index/serviceLevel:ServiceLevel": "ServiceLevel"
   }
  },
+ {
+  "pkg": "newrelic",
+  "mod": "index/user",
+  "fqn": "pulumi_newrelic",
+  "classes": {
+   "newrelic:index/user:User": "User"
+  }
+ },
  {
   "pkg": "newrelic",
   "mod": "index/workflow",

{pulumi_newrelic-5.19.0a1708065288 → pulumi_newrelic-5.20.0}/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-5.19.0a1708065288 → pulumi_newrelic-5.20.0}/pulumi_newrelic/cloud/_inputs.py

@@ -5966,6 +5966,8 @@ class AzureIntegrationsMonitorArgs:
                  resource_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[bool] enabled: A boolean value, that specifies if the integration needs to be active. Defaults to 'true' if not specified.
+               
+               > **IMPORTANT!** Using the `monitor` integration along with other polling integrations in this resource might lead to duplication of metrics. More information about this scenario may be found in the note in [this section](https://docs.newrelic.com/docs/infrastructure/microsoft-azure-integrations/azure-integrations-list/azure-monitor/#migration-from-polling) of New Relic's documentation on the Azure Monitor integration.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_tags: A list of resource tags associated with the resources that need to be excluded from monitoring.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] include_tags: A list of resource tags associated with the resources that need to be monitored, in a "key:value" format. If this is not specified, all resources will be monitored.
         :param pulumi.Input[int] metrics_polling_interval: The data polling interval in seconds.
@@ -5992,6 +5994,8 @@ class AzureIntegrationsMonitorArgs:
     def enabled(self) -> Optional[pulumi.Input[bool]]:
         """
         A boolean value, that specifies if the integration needs to be active. Defaults to 'true' if not specified.
+
+        > **IMPORTANT!** Using the `monitor` integration along with other polling integrations in this resource might lead to duplication of metrics. More information about this scenario may be found in the note in [this section](https://docs.newrelic.com/docs/infrastructure/microsoft-azure-integrations/azure-integrations-list/azure-monitor/#migration-from-polling) of New Relic's documentation on the Azure Monitor integration.
         """
         return pulumi.get(self, "enabled")
 

{pulumi_newrelic-5.19.0a1708065288 → pulumi_newrelic-5.20.0}/pulumi_newrelic/cloud/outputs.py

@@ -6750,6 +6750,8 @@ class AzureIntegrationsMonitor(dict):
                  resource_types: Optional[Sequence[str]] = None):
         """
         :param bool enabled: A boolean value, that specifies if the integration needs to be active. Defaults to 'true' if not specified.
+               
+               > **IMPORTANT!** Using the `monitor` integration along with other polling integrations in this resource might lead to duplication of metrics. More information about this scenario may be found in the note in [this section](https://docs.newrelic.com/docs/infrastructure/microsoft-azure-integrations/azure-integrations-list/azure-monitor/#migration-from-polling) of New Relic's documentation on the Azure Monitor integration.
         :param Sequence[str] exclude_tags: A list of resource tags associated with the resources that need to be excluded from monitoring.
         :param Sequence[str] include_tags: A list of resource tags associated with the resources that need to be monitored, in a "key:value" format. If this is not specified, all resources will be monitored.
         :param int metrics_polling_interval: The data polling interval in seconds.
@@ -6776,6 +6778,8 @@ class AzureIntegrationsMonitor(dict):
     def enabled(self) -> Optional[bool]:
         """
         A boolean value, that specifies if the integration needs to be active. Defaults to 'true' if not specified.
+
+        > **IMPORTANT!** Using the `monitor` integration along with other polling integrations in this resource might lead to duplication of metrics. More information about this scenario may be found in the note in [this section](https://docs.newrelic.com/docs/infrastructure/microsoft-azure-integrations/azure-integrations-list/azure-monitor/#migration-from-polling) of New Relic's documentation on the Azure Monitor integration.
         """
         return pulumi.get(self, "enabled")
 

{pulumi_newrelic-5.19.0a1708065288 → pulumi_newrelic-5.20.0}/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-5.20.0/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-5.20.0/pulumi_newrelic/get_user.py

@@ -0,0 +1,153 @@
+# 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__ = [
+    'GetUserResult',
+    'AwaitableGetUserResult',
+    'get_user',
+    'get_user_output',
+]
+
+@pulumi.output_type
+class GetUserResult:
+    """
+    A collection of values returned by getUser.
+    """
+    def __init__(__self__, authentication_domain_id=None, email_id=None, id=None, name=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 email_id and not isinstance(email_id, str):
+            raise TypeError("Expected argument 'email_id' to be a str")
+        pulumi.set(__self__, "email_id", email_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)
+
+    @property
+    @pulumi.getter(name="authenticationDomainId")
+    def authentication_domain_id(self) -> str:
+        return pulumi.get(self, "authentication_domain_id")
+
+    @property
+    @pulumi.getter(name="emailId")
+    def email_id(self) -> str:
+        return pulumi.get(self, "email_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ID of the matching user fetched.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        return pulumi.get(self, "name")
+
+
+class AwaitableGetUserResult(GetUserResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetUserResult(
+            authentication_domain_id=self.authentication_domain_id,
+            email_id=self.email_id,
+            id=self.id,
+            name=self.name)
+
+
+def get_user(authentication_domain_id: Optional[str] = None,
+             email_id: Optional[str] = None,
+             name: Optional[str] = None,
+             opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetUserResult:
+    """
+    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 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
+
+    foo = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    user_one = newrelic.get_user(authentication_domain_id=foo.id,
+        name="Test User")
+    user_two = newrelic.get_user(authentication_domain_id=foo.id,
+        email_id="test_user@random.com")
+    ```
+
+
+    :param str authentication_domain_id: The ID of the authentication domain the user to be searched for belongs to.
+    :param str email_id: The email ID of the user to search for.
+           
+           It should be noted that either `name` or `email_id` must be specified in order to retrieve a matching user.
+           
+           > **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.
+    """
+    __args__ = dict()
+    __args__['authenticationDomainId'] = authentication_domain_id
+    __args__['emailId'] = email_id
+    __args__['name'] = name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('newrelic:index/getUser:getUser', __args__, opts=opts, typ=GetUserResult).value
+
+    return AwaitableGetUserResult(
+        authentication_domain_id=pulumi.get(__ret__, 'authentication_domain_id'),
+        email_id=pulumi.get(__ret__, 'email_id'),
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'))
+
+
+@_utilities.lift_output_func(get_user)
+def get_user_output(authentication_domain_id: Optional[pulumi.Input[str]] = None,
+                    email_id: Optional[pulumi.Input[Optional[str]]] = None,
+                    name: Optional[pulumi.Input[Optional[str]]] = None,
+                    opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetUserResult]:
+    """
+    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 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
+
+    foo = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    user_one = newrelic.get_user(authentication_domain_id=foo.id,
+        name="Test User")
+    user_two = newrelic.get_user(authentication_domain_id=foo.id,
+        email_id="test_user@random.com")
+    ```
+
+
+    :param str authentication_domain_id: The ID of the authentication domain the user to be searched for belongs to.
+    :param str email_id: The email ID of the user to search for.
+           
+           It should be noted that either `name` or `email_id` must be specified in order to retrieve a matching user.
+           
+           > **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.
+    """
+    ...