pulumi-newrelic 5.40.0a1738941778__py3-none-any.whl → 5.41.0__py3-none-any.whl

pulumi_newrelic/_inputs.py

@@ -51,12 +51,18 @@ __all__ = [
     'NotificationDestinationSecureUrlArgsDict',
     'NrqlAlertConditionCriticalArgs',
     'NrqlAlertConditionCriticalArgsDict',
+    'NrqlAlertConditionCriticalPredictionArgs',
+    'NrqlAlertConditionCriticalPredictionArgsDict',
     'NrqlAlertConditionNrqlArgs',
     'NrqlAlertConditionNrqlArgsDict',
     'NrqlAlertConditionTermArgs',
     'NrqlAlertConditionTermArgsDict',
+    'NrqlAlertConditionTermPredictionArgs',
+    'NrqlAlertConditionTermPredictionArgsDict',
     'NrqlAlertConditionWarningArgs',
     'NrqlAlertConditionWarningArgsDict',
+    'NrqlAlertConditionWarningPredictionArgs',
+    'NrqlAlertConditionWarningPredictionArgsDict',
     'ObfuscationRuleActionArgs',
     'ObfuscationRuleActionArgsDict',
     'OneDashboardPageArgs',
@@ -1912,6 +1918,10 @@ if not MYPY:
         """
         One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
         """
+        prediction: NotRequired[pulumi.Input['NrqlAlertConditionCriticalPredictionArgsDict']]
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
         threshold_duration: NotRequired[pulumi.Input[int]]
         """
         The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
@@ -1933,6 +1943,7 @@ class NrqlAlertConditionCriticalArgs:
                  threshold: pulumi.Input[float],
                  duration: Optional[pulumi.Input[int]] = None,
                  operator: Optional[pulumi.Input[str]] = None,
+                 prediction: Optional[pulumi.Input['NrqlAlertConditionCriticalPredictionArgs']] = None,
                  threshold_duration: Optional[pulumi.Input[int]] = None,
                  threshold_occurrences: Optional[pulumi.Input[str]] = None,
                  time_function: Optional[pulumi.Input[str]] = None):
@@ -1940,6 +1951,7 @@ class NrqlAlertConditionCriticalArgs:
         :param pulumi.Input[float] threshold: For baseline conditions must be in range [1, 1000].
         :param pulumi.Input[int] duration: In minutes, must be in the range of 1 to 120 (inclusive).
         :param pulumi.Input[str] operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
+        :param pulumi.Input['NrqlAlertConditionCriticalPredictionArgs'] prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
         :param pulumi.Input[int] threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
         :param pulumi.Input[str] threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
         :param pulumi.Input[str] time_function: Valid values are: 'all' or 'any'
@@ -1952,6 +1964,8 @@ class NrqlAlertConditionCriticalArgs:
             pulumi.set(__self__, "duration", duration)
         if operator is not None:
             pulumi.set(__self__, "operator", operator)
+        if prediction is not None:
+            pulumi.set(__self__, "prediction", prediction)
         if threshold_duration is not None:
             pulumi.set(__self__, "threshold_duration", threshold_duration)
         if threshold_occurrences is not None:
@@ -1999,6 +2013,18 @@ class NrqlAlertConditionCriticalArgs:
     def operator(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "operator", value)
 
+    @property
+    @pulumi.getter
+    def prediction(self) -> Optional[pulumi.Input['NrqlAlertConditionCriticalPredictionArgs']]:
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
+        return pulumi.get(self, "prediction")
+
+    @prediction.setter
+    def prediction(self, value: Optional[pulumi.Input['NrqlAlertConditionCriticalPredictionArgs']]):
+        pulumi.set(self, "prediction", value)
+
     @property
     @pulumi.getter(name="thresholdDuration")
     def threshold_duration(self) -> Optional[pulumi.Input[int]]:
@@ -2037,6 +2063,58 @@ class NrqlAlertConditionCriticalArgs:
         pulumi.set(self, "time_function", value)
 
 
+if not MYPY:
+    class NrqlAlertConditionCriticalPredictionArgsDict(TypedDict):
+        predict_by: NotRequired[pulumi.Input[int]]
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        prefer_prediction_violation: NotRequired[pulumi.Input[bool]]
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+elif False:
+    NrqlAlertConditionCriticalPredictionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NrqlAlertConditionCriticalPredictionArgs:
+    def __init__(__self__, *,
+                 predict_by: Optional[pulumi.Input[int]] = None,
+                 prefer_prediction_violation: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[int] predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        :param pulumi.Input[bool] prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        if predict_by is not None:
+            pulumi.set(__self__, "predict_by", predict_by)
+        if prefer_prediction_violation is not None:
+            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
+
+    @property
+    @pulumi.getter(name="predictBy")
+    def predict_by(self) -> Optional[pulumi.Input[int]]:
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        return pulumi.get(self, "predict_by")
+
+    @predict_by.setter
+    def predict_by(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "predict_by", value)
+
+    @property
+    @pulumi.getter(name="preferPredictionViolation")
+    def prefer_prediction_violation(self) -> Optional[pulumi.Input[bool]]:
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        return pulumi.get(self, "prefer_prediction_violation")
+
+    @prefer_prediction_violation.setter
+    def prefer_prediction_violation(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "prefer_prediction_violation", value)
+
+
 if not MYPY:
     class NrqlAlertConditionNrqlArgsDict(TypedDict):
         query: pulumi.Input[str]
@@ -2143,6 +2221,10 @@ if not MYPY:
         """
         One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
         """
+        prediction: NotRequired[pulumi.Input['NrqlAlertConditionTermPredictionArgsDict']]
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
         priority: NotRequired[pulumi.Input[str]]
         """
         One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
@@ -2168,6 +2250,7 @@ class NrqlAlertConditionTermArgs:
                  threshold: pulumi.Input[float],
                  duration: Optional[pulumi.Input[int]] = None,
                  operator: Optional[pulumi.Input[str]] = None,
+                 prediction: Optional[pulumi.Input['NrqlAlertConditionTermPredictionArgs']] = None,
                  priority: Optional[pulumi.Input[str]] = None,
                  threshold_duration: Optional[pulumi.Input[int]] = None,
                  threshold_occurrences: Optional[pulumi.Input[str]] = None,
@@ -2176,6 +2259,7 @@ class NrqlAlertConditionTermArgs:
         :param pulumi.Input[float] threshold: For baseline conditions must be in range [1, 1000].
         :param pulumi.Input[int] duration: In minutes, must be in the range of 1 to 120 (inclusive).
         :param pulumi.Input[str] operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
+        :param pulumi.Input['NrqlAlertConditionTermPredictionArgs'] prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
         :param pulumi.Input[str] priority: One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
         :param pulumi.Input[int] threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
         :param pulumi.Input[str] threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
@@ -2189,6 +2273,8 @@ class NrqlAlertConditionTermArgs:
             pulumi.set(__self__, "duration", duration)
         if operator is not None:
             pulumi.set(__self__, "operator", operator)
+        if prediction is not None:
+            pulumi.set(__self__, "prediction", prediction)
         if priority is not None:
             pulumi.set(__self__, "priority", priority)
         if threshold_duration is not None:
@@ -2238,6 +2324,18 @@ class NrqlAlertConditionTermArgs:
     def operator(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "operator", value)
 
+    @property
+    @pulumi.getter
+    def prediction(self) -> Optional[pulumi.Input['NrqlAlertConditionTermPredictionArgs']]:
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
+        return pulumi.get(self, "prediction")
+
+    @prediction.setter
+    def prediction(self, value: Optional[pulumi.Input['NrqlAlertConditionTermPredictionArgs']]):
+        pulumi.set(self, "prediction", value)
+
     @property
     @pulumi.getter
     def priority(self) -> Optional[pulumi.Input[str]]:
@@ -2288,6 +2386,58 @@ class NrqlAlertConditionTermArgs:
         pulumi.set(self, "time_function", value)
 
 
+if not MYPY:
+    class NrqlAlertConditionTermPredictionArgsDict(TypedDict):
+        predict_by: NotRequired[pulumi.Input[int]]
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        prefer_prediction_violation: NotRequired[pulumi.Input[bool]]
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+elif False:
+    NrqlAlertConditionTermPredictionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NrqlAlertConditionTermPredictionArgs:
+    def __init__(__self__, *,
+                 predict_by: Optional[pulumi.Input[int]] = None,
+                 prefer_prediction_violation: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[int] predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        :param pulumi.Input[bool] prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        if predict_by is not None:
+            pulumi.set(__self__, "predict_by", predict_by)
+        if prefer_prediction_violation is not None:
+            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
+
+    @property
+    @pulumi.getter(name="predictBy")
+    def predict_by(self) -> Optional[pulumi.Input[int]]:
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        return pulumi.get(self, "predict_by")
+
+    @predict_by.setter
+    def predict_by(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "predict_by", value)
+
+    @property
+    @pulumi.getter(name="preferPredictionViolation")
+    def prefer_prediction_violation(self) -> Optional[pulumi.Input[bool]]:
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        return pulumi.get(self, "prefer_prediction_violation")
+
+    @prefer_prediction_violation.setter
+    def prefer_prediction_violation(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "prefer_prediction_violation", value)
+
+
 if not MYPY:
     class NrqlAlertConditionWarningArgsDict(TypedDict):
         threshold: pulumi.Input[float]
@@ -2302,6 +2452,10 @@ if not MYPY:
         """
         One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
         """
+        prediction: NotRequired[pulumi.Input['NrqlAlertConditionWarningPredictionArgsDict']]
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
         threshold_duration: NotRequired[pulumi.Input[int]]
         """
         The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
@@ -2323,6 +2477,7 @@ class NrqlAlertConditionWarningArgs:
                  threshold: pulumi.Input[float],
                  duration: Optional[pulumi.Input[int]] = None,
                  operator: Optional[pulumi.Input[str]] = None,
+                 prediction: Optional[pulumi.Input['NrqlAlertConditionWarningPredictionArgs']] = None,
                  threshold_duration: Optional[pulumi.Input[int]] = None,
                  threshold_occurrences: Optional[pulumi.Input[str]] = None,
                  time_function: Optional[pulumi.Input[str]] = None):
@@ -2330,6 +2485,7 @@ class NrqlAlertConditionWarningArgs:
         :param pulumi.Input[float] threshold: For baseline conditions must be in range [1, 1000].
         :param pulumi.Input[int] duration: In minutes, must be in the range of 1 to 120 (inclusive).
         :param pulumi.Input[str] operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
+        :param pulumi.Input['NrqlAlertConditionWarningPredictionArgs'] prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
         :param pulumi.Input[int] threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
         :param pulumi.Input[str] threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
         :param pulumi.Input[str] time_function: Valid values are: 'all' or 'any'
@@ -2342,6 +2498,8 @@ class NrqlAlertConditionWarningArgs:
             pulumi.set(__self__, "duration", duration)
         if operator is not None:
             pulumi.set(__self__, "operator", operator)
+        if prediction is not None:
+            pulumi.set(__self__, "prediction", prediction)
         if threshold_duration is not None:
             pulumi.set(__self__, "threshold_duration", threshold_duration)
         if threshold_occurrences is not None:
@@ -2389,6 +2547,18 @@ class NrqlAlertConditionWarningArgs:
     def operator(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "operator", value)
 
+    @property
+    @pulumi.getter
+    def prediction(self) -> Optional[pulumi.Input['NrqlAlertConditionWarningPredictionArgs']]:
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
+        return pulumi.get(self, "prediction")
+
+    @prediction.setter
+    def prediction(self, value: Optional[pulumi.Input['NrqlAlertConditionWarningPredictionArgs']]):
+        pulumi.set(self, "prediction", value)
+
     @property
     @pulumi.getter(name="thresholdDuration")
     def threshold_duration(self) -> Optional[pulumi.Input[int]]:
@@ -2427,6 +2597,58 @@ class NrqlAlertConditionWarningArgs:
         pulumi.set(self, "time_function", value)
 
 
+if not MYPY:
+    class NrqlAlertConditionWarningPredictionArgsDict(TypedDict):
+        predict_by: NotRequired[pulumi.Input[int]]
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        prefer_prediction_violation: NotRequired[pulumi.Input[bool]]
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+elif False:
+    NrqlAlertConditionWarningPredictionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NrqlAlertConditionWarningPredictionArgs:
+    def __init__(__self__, *,
+                 predict_by: Optional[pulumi.Input[int]] = None,
+                 prefer_prediction_violation: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[int] predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        :param pulumi.Input[bool] prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        if predict_by is not None:
+            pulumi.set(__self__, "predict_by", predict_by)
+        if prefer_prediction_violation is not None:
+            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
+
+    @property
+    @pulumi.getter(name="predictBy")
+    def predict_by(self) -> Optional[pulumi.Input[int]]:
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        return pulumi.get(self, "predict_by")
+
+    @predict_by.setter
+    def predict_by(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "predict_by", value)
+
+    @property
+    @pulumi.getter(name="preferPredictionViolation")
+    def prefer_prediction_violation(self) -> Optional[pulumi.Input[bool]]:
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        return pulumi.get(self, "prefer_prediction_violation")
+
+    @prefer_prediction_violation.setter
+    def prefer_prediction_violation(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "prefer_prediction_violation", value)
+
+
 if not MYPY:
     class ObfuscationRuleActionArgsDict(TypedDict):
         attributes: pulumi.Input[Sequence[pulumi.Input[str]]]

pulumi_newrelic/_utilities.py

@@ -89,12 +89,16 @@ def _get_semver_version():
     elif pep440_version.pre_tag == 'rc':
         prerelease = f"rc.{pep440_version.pre}"
     elif pep440_version.dev is not None:
+        # PEP440 has explicit support for dev builds, while semver encodes them as "prerelease" versions. To bridge 
+        # between the two, we convert our dev build version into a prerelease tag. This matches what all of our other
+        # packages do when constructing their own semver string.
         prerelease = f"dev.{pep440_version.dev}"
+    elif pep440_version.local is not None:
+        # PEP440 only allows a small set of prerelease tags, so when converting an arbitrary prerelease,
+        # PypiVersion in /pkg/codegen/python/utilities.go converts it to a local version. Therefore, we need to
+        # do the reverse conversion here and set the local version as the prerelease tag.
+        prerelease = pep440_version.local
 
-    # The only significant difference between PEP440 and semver as it pertains to us is that PEP440 has explicit support
-    # for dev builds, while semver encodes them as "prerelease" versions. In order to bridge between the two, we convert
-    # our dev build version into a prerelease tag. This matches what all of our other packages do when constructing
-    # their own semver string.
     return SemverVersion(major=major, minor=minor, patch=patch, prerelease=prerelease)
 
 

pulumi_newrelic/nrql_alert_condition.py

@@ -1046,11 +1046,23 @@ class NrqlAlertCondition(pulumi.CustomResource):
         - `threshold_occurrences` - (Optional) The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `at_least_once` (case insensitive).
         - `duration` - (Optional) **DEPRECATED:** Use `threshold_duration` instead. The duration of time, in _minutes_, that the threshold must violate for in order to create an incident. Must be within 1-120 (inclusive).
         - `time_function` - (Optional) **DEPRECATED:** Use `threshold_occurrences` instead. The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `any`.
+        - `prediction` - (Optional) **BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis.** Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for _static_ NRQL alert conditions. See Prediction below for details.
 
         > **NOTE:** When a `critical` or `warning` block is added to this resource, using either `duration` or `threshold_duration` (one of the two) is mandatory. Both of these should not be specified.
 
         > **NOTE:** When a `critical` or `warning` block is added to this resource, using either `time_function` or `threshold_occurrences` (one of the two) is mandatory. Both of these should not be specified.
 
+        ### Prediction
+
+        > **BETA PREVIEW:** The `prediction` block is in limited release and only enabled for preview on a per-account basis.
+
+        > **NOTE:** The `prediction` block is only available for _static_ NRQL alert conditions.
+
+        The `prediction` block supports the following arguments:
+
+        - `predict_by` - (Optional) The duration, in seconds, that the prediction should look into the future. Default is 3600 seconds (1 hour).
+        - `prefer_prediction_violation` - (Optional) If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening. Default is false.
+
         ## Additional Examples
 
         ##### Type: `baseline`
@@ -1345,11 +1357,23 @@ class NrqlAlertCondition(pulumi.CustomResource):
         - `threshold_occurrences` - (Optional) The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `at_least_once` (case insensitive).
         - `duration` - (Optional) **DEPRECATED:** Use `threshold_duration` instead. The duration of time, in _minutes_, that the threshold must violate for in order to create an incident. Must be within 1-120 (inclusive).
         - `time_function` - (Optional) **DEPRECATED:** Use `threshold_occurrences` instead. The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `any`.
+        - `prediction` - (Optional) **BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis.** Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for _static_ NRQL alert conditions. See Prediction below for details.
 
         > **NOTE:** When a `critical` or `warning` block is added to this resource, using either `duration` or `threshold_duration` (one of the two) is mandatory. Both of these should not be specified.
 
         > **NOTE:** When a `critical` or `warning` block is added to this resource, using either `time_function` or `threshold_occurrences` (one of the two) is mandatory. Both of these should not be specified.
 
+        ### Prediction
+
+        > **BETA PREVIEW:** The `prediction` block is in limited release and only enabled for preview on a per-account basis.
+
+        > **NOTE:** The `prediction` block is only available for _static_ NRQL alert conditions.
+
+        The `prediction` block supports the following arguments:
+
+        - `predict_by` - (Optional) The duration, in seconds, that the prediction should look into the future. Default is 3600 seconds (1 hour).
+        - `prefer_prediction_violation` - (Optional) If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening. Default is false.
+
         ## Additional Examples
 
         ##### Type: `baseline`

pulumi_newrelic/outputs.py

@@ -34,9 +34,12 @@ __all__ = [
     'NotificationDestinationProperty',
     'NotificationDestinationSecureUrl',
     'NrqlAlertConditionCritical',
+    'NrqlAlertConditionCriticalPrediction',
     'NrqlAlertConditionNrql',
     'NrqlAlertConditionTerm',
+    'NrqlAlertConditionTermPrediction',
     'NrqlAlertConditionWarning',
+    'NrqlAlertConditionWarningPrediction',
     'ObfuscationRuleAction',
     'OneDashboardPage',
     'OneDashboardPageWidgetArea',
@@ -1350,6 +1353,7 @@ class NrqlAlertConditionCritical(dict):
                  threshold: float,
                  duration: Optional[int] = None,
                  operator: Optional[str] = None,
+                 prediction: Optional['outputs.NrqlAlertConditionCriticalPrediction'] = None,
                  threshold_duration: Optional[int] = None,
                  threshold_occurrences: Optional[str] = None,
                  time_function: Optional[str] = None):
@@ -1357,6 +1361,7 @@ class NrqlAlertConditionCritical(dict):
         :param float threshold: For baseline conditions must be in range [1, 1000].
         :param int duration: In minutes, must be in the range of 1 to 120 (inclusive).
         :param str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
+        :param 'NrqlAlertConditionCriticalPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
         :param int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
         :param str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
         :param str time_function: Valid values are: 'all' or 'any'
@@ -1366,6 +1371,8 @@ class NrqlAlertConditionCritical(dict):
             pulumi.set(__self__, "duration", duration)
         if operator is not None:
             pulumi.set(__self__, "operator", operator)
+        if prediction is not None:
+            pulumi.set(__self__, "prediction", prediction)
         if threshold_duration is not None:
             pulumi.set(__self__, "threshold_duration", threshold_duration)
         if threshold_occurrences is not None:
@@ -1398,6 +1405,14 @@ class NrqlAlertConditionCritical(dict):
         """
         return pulumi.get(self, "operator")
 
+    @property
+    @pulumi.getter
+    def prediction(self) -> Optional['outputs.NrqlAlertConditionCriticalPrediction']:
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
+        return pulumi.get(self, "prediction")
+
     @property
     @pulumi.getter(name="thresholdDuration")
     def threshold_duration(self) -> Optional[int]:
@@ -1424,6 +1439,56 @@ class NrqlAlertConditionCritical(dict):
         return pulumi.get(self, "time_function")
 
 
+@pulumi.output_type
+class NrqlAlertConditionCriticalPrediction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "predictBy":
+            suggest = "predict_by"
+        elif key == "preferPredictionViolation":
+            suggest = "prefer_prediction_violation"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionCriticalPrediction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NrqlAlertConditionCriticalPrediction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NrqlAlertConditionCriticalPrediction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 predict_by: Optional[int] = None,
+                 prefer_prediction_violation: Optional[bool] = None):
+        """
+        :param int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        :param bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        if predict_by is not None:
+            pulumi.set(__self__, "predict_by", predict_by)
+        if prefer_prediction_violation is not None:
+            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
+
+    @property
+    @pulumi.getter(name="predictBy")
+    def predict_by(self) -> Optional[int]:
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        return pulumi.get(self, "predict_by")
+
+    @property
+    @pulumi.getter(name="preferPredictionViolation")
+    def prefer_prediction_violation(self) -> Optional[bool]:
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        return pulumi.get(self, "prefer_prediction_violation")
+
+
 @pulumi.output_type
 class NrqlAlertConditionNrql(dict):
     @staticmethod
@@ -1524,6 +1589,7 @@ class NrqlAlertConditionTerm(dict):
                  threshold: float,
                  duration: Optional[int] = None,
                  operator: Optional[str] = None,
+                 prediction: Optional['outputs.NrqlAlertConditionTermPrediction'] = None,
                  priority: Optional[str] = None,
                  threshold_duration: Optional[int] = None,
                  threshold_occurrences: Optional[str] = None,
@@ -1532,6 +1598,7 @@ class NrqlAlertConditionTerm(dict):
         :param float threshold: For baseline conditions must be in range [1, 1000].
         :param int duration: In minutes, must be in the range of 1 to 120 (inclusive).
         :param str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
+        :param 'NrqlAlertConditionTermPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
         :param str priority: One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
         :param int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
         :param str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
@@ -1542,6 +1609,8 @@ class NrqlAlertConditionTerm(dict):
             pulumi.set(__self__, "duration", duration)
         if operator is not None:
             pulumi.set(__self__, "operator", operator)
+        if prediction is not None:
+            pulumi.set(__self__, "prediction", prediction)
         if priority is not None:
             pulumi.set(__self__, "priority", priority)
         if threshold_duration is not None:
@@ -1576,6 +1645,14 @@ class NrqlAlertConditionTerm(dict):
         """
         return pulumi.get(self, "operator")
 
+    @property
+    @pulumi.getter
+    def prediction(self) -> Optional['outputs.NrqlAlertConditionTermPrediction']:
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
+        return pulumi.get(self, "prediction")
+
     @property
     @pulumi.getter
     def priority(self) -> Optional[str]:
@@ -1610,6 +1687,56 @@ class NrqlAlertConditionTerm(dict):
         return pulumi.get(self, "time_function")
 
 
+@pulumi.output_type
+class NrqlAlertConditionTermPrediction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "predictBy":
+            suggest = "predict_by"
+        elif key == "preferPredictionViolation":
+            suggest = "prefer_prediction_violation"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionTermPrediction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NrqlAlertConditionTermPrediction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NrqlAlertConditionTermPrediction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 predict_by: Optional[int] = None,
+                 prefer_prediction_violation: Optional[bool] = None):
+        """
+        :param int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        :param bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        if predict_by is not None:
+            pulumi.set(__self__, "predict_by", predict_by)
+        if prefer_prediction_violation is not None:
+            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
+
+    @property
+    @pulumi.getter(name="predictBy")
+    def predict_by(self) -> Optional[int]:
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        return pulumi.get(self, "predict_by")
+
+    @property
+    @pulumi.getter(name="preferPredictionViolation")
+    def prefer_prediction_violation(self) -> Optional[bool]:
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        return pulumi.get(self, "prefer_prediction_violation")
+
+
 @pulumi.output_type
 class NrqlAlertConditionWarning(dict):
     @staticmethod
@@ -1637,6 +1764,7 @@ class NrqlAlertConditionWarning(dict):
                  threshold: float,
                  duration: Optional[int] = None,
                  operator: Optional[str] = None,
+                 prediction: Optional['outputs.NrqlAlertConditionWarningPrediction'] = None,
                  threshold_duration: Optional[int] = None,
                  threshold_occurrences: Optional[str] = None,
                  time_function: Optional[str] = None):
@@ -1644,6 +1772,7 @@ class NrqlAlertConditionWarning(dict):
         :param float threshold: For baseline conditions must be in range [1, 1000].
         :param int duration: In minutes, must be in the range of 1 to 120 (inclusive).
         :param str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
+        :param 'NrqlAlertConditionWarningPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
         :param int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
         :param str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
         :param str time_function: Valid values are: 'all' or 'any'
@@ -1653,6 +1782,8 @@ class NrqlAlertConditionWarning(dict):
             pulumi.set(__self__, "duration", duration)
         if operator is not None:
             pulumi.set(__self__, "operator", operator)
+        if prediction is not None:
+            pulumi.set(__self__, "prediction", prediction)
         if threshold_duration is not None:
             pulumi.set(__self__, "threshold_duration", threshold_duration)
         if threshold_occurrences is not None:
@@ -1685,6 +1816,14 @@ class NrqlAlertConditionWarning(dict):
         """
         return pulumi.get(self, "operator")
 
+    @property
+    @pulumi.getter
+    def prediction(self) -> Optional['outputs.NrqlAlertConditionWarningPrediction']:
+        """
+        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
+        """
+        return pulumi.get(self, "prediction")
+
     @property
     @pulumi.getter(name="thresholdDuration")
     def threshold_duration(self) -> Optional[int]:
@@ -1711,6 +1850,56 @@ class NrqlAlertConditionWarning(dict):
         return pulumi.get(self, "time_function")
 
 
+@pulumi.output_type
+class NrqlAlertConditionWarningPrediction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "predictBy":
+            suggest = "predict_by"
+        elif key == "preferPredictionViolation":
+            suggest = "prefer_prediction_violation"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionWarningPrediction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NrqlAlertConditionWarningPrediction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NrqlAlertConditionWarningPrediction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 predict_by: Optional[int] = None,
+                 prefer_prediction_violation: Optional[bool] = None):
+        """
+        :param int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        :param bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        if predict_by is not None:
+            pulumi.set(__self__, "predict_by", predict_by)
+        if prefer_prediction_violation is not None:
+            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
+
+    @property
+    @pulumi.getter(name="predictBy")
+    def predict_by(self) -> Optional[int]:
+        """
+        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
+        """
+        return pulumi.get(self, "predict_by")
+
+    @property
+    @pulumi.getter(name="preferPredictionViolation")
+    def prefer_prediction_violation(self) -> Optional[bool]:
+        """
+        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
+        """
+        return pulumi.get(self, "prefer_prediction_violation")
+
+
 @pulumi.output_type
 class ObfuscationRuleAction(dict):
     @staticmethod

pulumi_newrelic/pulumi-plugin.json

@@ -1,5 +1,5 @@
 {
   "resource": true,
   "name": "newrelic",
-  "version": "5.40.0-alpha.1738941778"
+  "version": "5.41.0"
 }

{pulumi_newrelic-5.40.0a1738941778.dist-info → pulumi_newrelic-5.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pulumi_newrelic
-Version: 5.40.0a1738941778
+Version: 5.41.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.40.0a1738941778.dist-info → pulumi_newrelic-5.41.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pulumi_newrelic/__init__.py,sha256=q0NdPqgZC1kS4XOkgRZa7J_iuaWxIkMKXQfOnC5CysU,11535
-pulumi_newrelic/_inputs.py,sha256=70CkqfnaV3xViBsSreQggp7UL3FKVxdDg2EgbLR5Sjg,797096
-pulumi_newrelic/_utilities.py,sha256=-gxwnD6__OYdSf8jJgJijNuu-UHUwi5pJ1H7-eIHDhg,10504
+pulumi_newrelic/_inputs.py,sha256=P3qXyc_wIl3Rk01kIClfgnZbLGyG9osKt5yEc44OgLU,813264
+pulumi_newrelic/_utilities.py,sha256=yyuODPikZ9pto3JWJRfMJo98dWmQ5_y45-TVcZG_K8Y,10807
 pulumi_newrelic/account_management.py,sha256=qFD7xsT6kNFNY3ZEO-15E4T6mSIOQ6uw_Goqf7-NkTU,8963
 pulumi_newrelic/alert_channel.py,sha256=QNF_jzaDJLKD78qxtBnDpRaAVMJigmGYQtSWuCEIC7g,21825
 pulumi_newrelic/alert_condition.py,sha256=1Z6zrlx82N6hrQDpIMCAATUx4YH8oXiS1pNmGiW94bQ,46708
@@ -33,16 +33,16 @@ pulumi_newrelic/log_parsing_rule.py,sha256=HOCj_6SaSGNkJdhXalrETqRapE550cdnpe1PJ
 pulumi_newrelic/monitor_downtime.py,sha256=OKeKMevKKOTn4t3C2uhRX4rXuG-OikhQZTmRy6JtBfQ,40862
 pulumi_newrelic/notification_channel.py,sha256=5M1toakKA-65WA5pec0HMp4t7eX9OkcSFs53pNcUQTI,47179
 pulumi_newrelic/notification_destination.py,sha256=l7BC67LiRM4EXCtf3eNnWnrb-o1P7_9RmpsC4Rga6q4,39181
-pulumi_newrelic/nrql_alert_condition.py,sha256=IUl0PcymIcySKWesPYYKHN5a6NWFzoAeORJh1BDZnog,111967
+pulumi_newrelic/nrql_alert_condition.py,sha256=KGZDpiXD29I79e42ASD6-gWz_MOyiAb57h4qVmgUXBc,114429
 pulumi_newrelic/nrql_drop_rule.py,sha256=T33XlLYt7RfQQeazJzF2_GtLrJL1lxiG1PmXRdFL8eA,17712
 pulumi_newrelic/obfuscation_expression.py,sha256=V3YlnP1ZHyCbWnCgykm6uOHgyj0IUYqxpWllM7z43fE,12517
 pulumi_newrelic/obfuscation_rule.py,sha256=HzyDhyK3-qkrgiERkAZs0HiC1ToH8vaeXXoLjx6fyss,18043
 pulumi_newrelic/one_dashboard.py,sha256=91XJ8Dic5u66ZvUx7-uyZpNZJ306BOq9mLBULMe7-oQ,20854
 pulumi_newrelic/one_dashboard_json.py,sha256=EZqg6akwsh-SqsRjCmQzDjgsjvbIfKsX2zt3vjQ8bYE,12796
 pulumi_newrelic/one_dashboard_raw.py,sha256=__3ZuSPVubBaC5iPa9V6q1SG7lHFcpNdVsLXQie5c7U,23668
-pulumi_newrelic/outputs.py,sha256=GpBj8cVexHhJXbpzkqZBbcaOSQkLybzZ46vEKFaREPg,576475
+pulumi_newrelic/outputs.py,sha256=1S09iXWXxMCrDIuG5-A4yWmYhp-cps-O3zMKak2Q1qc,588609
 pulumi_newrelic/provider.py,sha256=OjBqZT1L0Jt_1-c3zMSSGA03zIZjgif7RrThna-ojng,18493
-pulumi_newrelic/pulumi-plugin.json,sha256=pJ3dbRECteP7AZoO-rND5O0hOh3yeknczvEQtigxZj8,85
+pulumi_newrelic/pulumi-plugin.json,sha256=u7MnYrw6NTu2anuvZMESIL0fDbqKXL-olL7xwnp4cAk,68
 pulumi_newrelic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulumi_newrelic/service_level.py,sha256=Dk_AoEFTmaJAg5v8SKBN4-a4T-MGXDbPubxsnB98sFk,28980
 pulumi_newrelic/user.py,sha256=guVvPGAeuR-mQ6_bA_MvBP7GY2grEmnbdNkc_5hs1us,19116
@@ -84,7 +84,7 @@ pulumi_newrelic/synthetics/private_location.py,sha256=-pj6W9dg9fB-jtnrTH8wnd7o_j
 pulumi_newrelic/synthetics/script_monitor.py,sha256=fwRaviLtkQ0ViK3V1W98npxcN_qBXFevwuHgHArl3m0,66220
 pulumi_newrelic/synthetics/secure_credential.py,sha256=EilBGvvvqmADHo1VPeWfQkCdc2GYRO8Dq9-lktE7Y3M,15776
 pulumi_newrelic/synthetics/step_monitor.py,sha256=7tqzQ9InEMRdfAr9K_vpLm-OCPHyIKEH4f8CT2BxaLQ,49116
-pulumi_newrelic-5.40.0a1738941778.dist-info/METADATA,sha256=FtPaF2bPQgqR_uegyr1Omw95n7TXzdecBsfdY2NbE-E,3963
-pulumi_newrelic-5.40.0a1738941778.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-pulumi_newrelic-5.40.0a1738941778.dist-info/top_level.txt,sha256=BjE1Wsu6Ah_A7k08uV5vRSZ2R_5uY3wFvSWJaa7ZoQk,16
-pulumi_newrelic-5.40.0a1738941778.dist-info/RECORD,,
+pulumi_newrelic-5.41.0.dist-info/METADATA,sha256=qdvL_elkg0AUalafCyZ5AVFlVDCvTZZtily7mqYzWKQ,3952
+pulumi_newrelic-5.41.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pulumi_newrelic-5.41.0.dist-info/top_level.txt,sha256=BjE1Wsu6Ah_A7k08uV5vRSZ2R_5uY3wFvSWJaa7ZoQk,16
+pulumi_newrelic-5.41.0.dist-info/RECORD,,