pulumi-newrelic 5.20.0a1709643785__py3-none-any.whl → 5.39.0a1736834464__py3-none-any.whl

pulumi_newrelic/get_entity.py

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 from . import outputs
 from ._inputs import *
@@ -23,16 +28,19 @@ class GetEntityResult:
     """
     A collection of values returned by getEntity.
     """
-    def __init__(__self__, account_id=None, application_id=None, domain=None, guid=None, id=None, ignore_case=None, name=None, serving_apm_application_id=None, tags=None, type=None):
-        if account_id and not isinstance(account_id, int):
-            raise TypeError("Expected argument 'account_id' to be a int")
+    def __init__(__self__, account_id=None, application_id=None, domain=None, entity_tags=None, guid=None, id=None, ignore_case=None, ignore_not_found=None, name=None, serving_apm_application_id=None, tags=None, type=None):
+        if account_id and not isinstance(account_id, str):
+            raise TypeError("Expected argument 'account_id' to be a str")
         pulumi.set(__self__, "account_id", account_id)
-        if application_id and not isinstance(application_id, int):
-            raise TypeError("Expected argument 'application_id' to be a int")
+        if application_id and not isinstance(application_id, str):
+            raise TypeError("Expected argument 'application_id' to be a str")
         pulumi.set(__self__, "application_id", application_id)
         if domain and not isinstance(domain, str):
             raise TypeError("Expected argument 'domain' to be a str")
         pulumi.set(__self__, "domain", domain)
+        if entity_tags and not isinstance(entity_tags, str):
+            raise TypeError("Expected argument 'entity_tags' to be a str")
+        pulumi.set(__self__, "entity_tags", entity_tags)
         if guid and not isinstance(guid, str):
             raise TypeError("Expected argument 'guid' to be a str")
         pulumi.set(__self__, "guid", guid)
@@ -42,11 +50,14 @@ class GetEntityResult:
         if ignore_case and not isinstance(ignore_case, bool):
             raise TypeError("Expected argument 'ignore_case' to be a bool")
         pulumi.set(__self__, "ignore_case", ignore_case)
+        if ignore_not_found and not isinstance(ignore_not_found, bool):
+            raise TypeError("Expected argument 'ignore_not_found' to be a bool")
+        pulumi.set(__self__, "ignore_not_found", ignore_not_found)
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
-        if serving_apm_application_id and not isinstance(serving_apm_application_id, int):
-            raise TypeError("Expected argument 'serving_apm_application_id' to be a int")
+        if serving_apm_application_id and not isinstance(serving_apm_application_id, str):
+            raise TypeError("Expected argument 'serving_apm_application_id' to be a str")
         pulumi.set(__self__, "serving_apm_application_id", serving_apm_application_id)
         if tags and not isinstance(tags, list):
             raise TypeError("Expected argument 'tags' to be a list")
@@ -57,12 +68,12 @@ class GetEntityResult:
 
     @property
     @pulumi.getter(name="accountId")
-    def account_id(self) -> int:
+    def account_id(self) -> str:
         return pulumi.get(self, "account_id")
 
     @property
     @pulumi.getter(name="applicationId")
-    def application_id(self) -> int:
+    def application_id(self) -> str:
         """
         The domain-specific application ID of the entity. Only returned for APM and Browser applications.
         """
@@ -73,6 +84,15 @@ class GetEntityResult:
     def domain(self) -> str:
         return pulumi.get(self, "domain")
 
+    @property
+    @pulumi.getter(name="entityTags")
+    def entity_tags(self) -> str:
+        """
+        A JSON-encoded string, comprising tags associated with the entity fetched.
+        * See the **Additional Examples** section below, for an illustration depicting the usage of `jsondecode` with the attribute `entity_tags`, to get the tags associated with the entity fetched.
+        """
+        return pulumi.get(self, "entity_tags")
+
     @property
     @pulumi.getter
     def guid(self) -> str:
@@ -94,6 +114,11 @@ class GetEntityResult:
     def ignore_case(self) -> Optional[bool]:
         return pulumi.get(self, "ignore_case")
 
+    @property
+    @pulumi.getter(name="ignoreNotFound")
+    def ignore_not_found(self) -> Optional[bool]:
+        return pulumi.get(self, "ignore_not_found")
+
     @property
     @pulumi.getter
     def name(self) -> str:
@@ -101,7 +126,7 @@ class GetEntityResult:
 
     @property
     @pulumi.getter(name="servingApmApplicationId")
-    def serving_apm_application_id(self) -> int:
+    def serving_apm_application_id(self) -> str:
         """
         The browser-specific ID of the backing APM entity. Only returned for Browser applications.
         """
@@ -127,66 +152,47 @@ class AwaitableGetEntityResult(GetEntityResult):
             account_id=self.account_id,
             application_id=self.application_id,
             domain=self.domain,
+            entity_tags=self.entity_tags,
             guid=self.guid,
             id=self.id,
             ignore_case=self.ignore_case,
+            ignore_not_found=self.ignore_not_found,
             name=self.name,
             serving_apm_application_id=self.serving_apm_application_id,
             tags=self.tags,
             type=self.type)
 
 
-def get_entity(account_id: Optional[int] = None,
+def get_entity(account_id: Optional[str] = None,
                domain: Optional[str] = None,
+               entity_tags: Optional[str] = None,
                ignore_case: Optional[bool] = None,
+               ignore_not_found: Optional[bool] = None,
                name: Optional[str] = None,
-               tags: Optional[Sequence[pulumi.InputType['GetEntityTagArgs']]] = None,
+               tags: Optional[Sequence[Union['GetEntityTagArgs', 'GetEntityTagArgsDict']]] = None,
                type: Optional[str] = None,
                opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetEntityResult:
     """
-    Use this data source to get information about a specific entity in New Relic One that already exists.
-
-    ## Additional Examples
-
-    > If the entities are not found please try again without providing the `type` field.
-
-    ### Query for an OTEL entity
+    Use this data source to access information about an existing resource.
 
-    ```python
-    import pulumi
-    import pulumi_newrelic as newrelic
-
-    app = newrelic.get_entity(domain="EXT",
-        name="my-otel-app",
-        tags=[newrelic.GetEntityTagArgs(
-            key="accountID",
-            value="12345",
-        )],
-        type="SERVICE")
-    ```
-
-    ### Query for an entity by type (AWS Lambda entity in this example)
-
-    ```python
-    import pulumi
-    import pulumi_newrelic as newrelic
-
-    app = newrelic.get_entity(name="my_lambda_trace",
-        type="AWSLAMBDAFUNCTION")
-    ```
-
-
-    :param int account_id: The New Relic account ID the entity to be returned would be associated with, i.e. if specified, the data source would filter matching entities received by `account_id` and return the first match. If not, matching entities are filtered by the account ID specified in the configuration of the provider. See the **Example: Filter By Account ID** section above for more details.
+    :param str account_id: The New Relic account ID the entity to be returned would be associated with, i.e. if specified, the data source would filter matching entities received by `account_id` and return the first match. If not, matching entities are filtered by the account ID specified in the configuration of the provider. See the **Example: Filter By Account ID** section above for more details.
     :param str domain: The entity's domain. Valid values are APM, BROWSER, INFRA, MOBILE, SYNTH, and EXT. If not specified, all domains are searched.
+    :param str entity_tags: A JSON-encoded string, comprising tags associated with the entity fetched.
+           * See the **Additional Examples** section below, for an illustration depicting the usage of `jsondecode` with the attribute `entity_tags`, to get the tags associated with the entity fetched.
     :param bool ignore_case: Ignore case of the `name` when searching for the entity. Defaults to false.
+    :param bool ignore_not_found: A boolean argument that, when set to true, prevents an error from being thrown when the queried entity is not found. Instead, a warning is displayed. Defaults to `false`.
+           
+           > **WARNING:** Setting the `ignore_not_found` argument to `true` will display an 'entity not found' warning instead of throwing an error. This can lead to downstream errors if the values of attributes exported by this data source are used elsewhere, as all of these values would be null. Please use this argument at your own risk.
     :param str name: The name of the entity in New Relic One.  The first entity matching this name for the given search parameters will be returned.
-    :param Sequence[pulumi.InputType['GetEntityTagArgs']] tags: A tag applied to the entity. See Nested tag blocks below for details.
+    :param Sequence[Union['GetEntityTagArgs', 'GetEntityTagArgsDict']] tags: A tag applied to the entity. See Nested tag blocks below for details.
     :param str type: The entity's type. Valid values are APPLICATION, DASHBOARD, HOST, MONITOR, WORKLOAD, AWSLAMBDAFUNCTION, SERVICE_LEVEL, and KEY_TRANSACTION. Note: Other entity types may also be queryable as the list of entity types may fluctuate over time.
     """
     __args__ = dict()
     __args__['accountId'] = account_id
     __args__['domain'] = domain
+    __args__['entityTags'] = entity_tags
     __args__['ignoreCase'] = ignore_case
+    __args__['ignoreNotFound'] = ignore_not_found
     __args__['name'] = name
     __args__['tags'] = tags
     __args__['type'] = type
@@ -197,61 +203,60 @@ def get_entity(account_id: Optional[int] = None,
         account_id=pulumi.get(__ret__, 'account_id'),
         application_id=pulumi.get(__ret__, 'application_id'),
         domain=pulumi.get(__ret__, 'domain'),
+        entity_tags=pulumi.get(__ret__, 'entity_tags'),
         guid=pulumi.get(__ret__, 'guid'),
         id=pulumi.get(__ret__, 'id'),
         ignore_case=pulumi.get(__ret__, 'ignore_case'),
+        ignore_not_found=pulumi.get(__ret__, 'ignore_not_found'),
         name=pulumi.get(__ret__, 'name'),
         serving_apm_application_id=pulumi.get(__ret__, 'serving_apm_application_id'),
         tags=pulumi.get(__ret__, 'tags'),
         type=pulumi.get(__ret__, 'type'))
-
-
-@_utilities.lift_output_func(get_entity)
-def get_entity_output(account_id: Optional[pulumi.Input[Optional[int]]] = None,
+def get_entity_output(account_id: Optional[pulumi.Input[Optional[str]]] = None,
                       domain: Optional[pulumi.Input[Optional[str]]] = None,
+                      entity_tags: Optional[pulumi.Input[Optional[str]]] = None,
                       ignore_case: Optional[pulumi.Input[Optional[bool]]] = None,
+                      ignore_not_found: Optional[pulumi.Input[Optional[bool]]] = None,
                       name: Optional[pulumi.Input[str]] = None,
-                      tags: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['GetEntityTagArgs']]]]] = None,
+                      tags: Optional[pulumi.Input[Optional[Sequence[Union['GetEntityTagArgs', 'GetEntityTagArgsDict']]]]] = None,
                       type: Optional[pulumi.Input[Optional[str]]] = None,
-                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetEntityResult]:
+                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetEntityResult]:
     """
-    Use this data source to get information about a specific entity in New Relic One that already exists.
+    Use this data source to access information about an existing resource.
 
-    ## Additional Examples
-
-    > If the entities are not found please try again without providing the `type` field.
-
-    ### Query for an OTEL entity
-
-    ```python
-    import pulumi
-    import pulumi_newrelic as newrelic
-
-    app = newrelic.get_entity(domain="EXT",
-        name="my-otel-app",
-        tags=[newrelic.GetEntityTagArgs(
-            key="accountID",
-            value="12345",
-        )],
-        type="SERVICE")
-    ```
-
-    ### Query for an entity by type (AWS Lambda entity in this example)
-
-    ```python
-    import pulumi
-    import pulumi_newrelic as newrelic
-
-    app = newrelic.get_entity(name="my_lambda_trace",
-        type="AWSLAMBDAFUNCTION")
-    ```
-
-
-    :param int account_id: The New Relic account ID the entity to be returned would be associated with, i.e. if specified, the data source would filter matching entities received by `account_id` and return the first match. If not, matching entities are filtered by the account ID specified in the configuration of the provider. See the **Example: Filter By Account ID** section above for more details.
+    :param str account_id: The New Relic account ID the entity to be returned would be associated with, i.e. if specified, the data source would filter matching entities received by `account_id` and return the first match. If not, matching entities are filtered by the account ID specified in the configuration of the provider. See the **Example: Filter By Account ID** section above for more details.
     :param str domain: The entity's domain. Valid values are APM, BROWSER, INFRA, MOBILE, SYNTH, and EXT. If not specified, all domains are searched.
+    :param str entity_tags: A JSON-encoded string, comprising tags associated with the entity fetched.
+           * See the **Additional Examples** section below, for an illustration depicting the usage of `jsondecode` with the attribute `entity_tags`, to get the tags associated with the entity fetched.
     :param bool ignore_case: Ignore case of the `name` when searching for the entity. Defaults to false.
+    :param bool ignore_not_found: A boolean argument that, when set to true, prevents an error from being thrown when the queried entity is not found. Instead, a warning is displayed. Defaults to `false`.
+           
+           > **WARNING:** Setting the `ignore_not_found` argument to `true` will display an 'entity not found' warning instead of throwing an error. This can lead to downstream errors if the values of attributes exported by this data source are used elsewhere, as all of these values would be null. Please use this argument at your own risk.
     :param str name: The name of the entity in New Relic One.  The first entity matching this name for the given search parameters will be returned.
-    :param Sequence[pulumi.InputType['GetEntityTagArgs']] tags: A tag applied to the entity. See Nested tag blocks below for details.
+    :param Sequence[Union['GetEntityTagArgs', 'GetEntityTagArgsDict']] tags: A tag applied to the entity. See Nested tag blocks below for details.
     :param str type: The entity's type. Valid values are APPLICATION, DASHBOARD, HOST, MONITOR, WORKLOAD, AWSLAMBDAFUNCTION, SERVICE_LEVEL, and KEY_TRANSACTION. Note: Other entity types may also be queryable as the list of entity types may fluctuate over time.
     """
-    ...
+    __args__ = dict()
+    __args__['accountId'] = account_id
+    __args__['domain'] = domain
+    __args__['entityTags'] = entity_tags
+    __args__['ignoreCase'] = ignore_case
+    __args__['ignoreNotFound'] = ignore_not_found
+    __args__['name'] = name
+    __args__['tags'] = tags
+    __args__['type'] = type
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getEntity:getEntity', __args__, opts=opts, typ=GetEntityResult)
+    return __ret__.apply(lambda __response__: GetEntityResult(
+        account_id=pulumi.get(__response__, 'account_id'),
+        application_id=pulumi.get(__response__, 'application_id'),
+        domain=pulumi.get(__response__, 'domain'),
+        entity_tags=pulumi.get(__response__, 'entity_tags'),
+        guid=pulumi.get(__response__, 'guid'),
+        id=pulumi.get(__response__, 'id'),
+        ignore_case=pulumi.get(__response__, 'ignore_case'),
+        ignore_not_found=pulumi.get(__response__, 'ignore_not_found'),
+        name=pulumi.get(__response__, 'name'),
+        serving_apm_application_id=pulumi.get(__response__, 'serving_apm_application_id'),
+        tags=pulumi.get(__response__, 'tags'),
+        type=pulumi.get(__response__, 'type')))

pulumi_newrelic/get_group.py

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
@@ -88,11 +93,30 @@ def get_group(authentication_domain_id: Optional[str] = None,
     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,
+    foo = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    foo_get_group = newrelic.get_group(authentication_domain_id=foo.id,
         name="Test Group")
     ```
 
+    ## Additional Examples
+
+    The following example demonstrates utilizing attributes exported by this data source.
+
+    In order to directly reference the attributes `id` and `user_ids` from this data source, you can use the syntax `data.newrelic_group.foo.id` and `data.newrelic_group.foo.user_ids`, respectively. However, if you need to assign these values to local variables and perform further processing (such as conditionally formatting the `user_ids` attribute as shown in the example below), consider using the provided configuration. These variables can then be accessed elsewhere using the syntax `local.id` and `local.user_id`, respectively.
+
+    ```python
+    import pulumi
+    import pulumi_newrelic as newrelic
+    import pulumi_std as std
+
+    foo = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    foo_get_group = newrelic.get_group(authentication_domain_id=foo.id,
+        name="Test Group")
+    id = foo_get_group.id
+    user_ids = std.join(separator=", ",
+        input=foo_get_group.user_ids).result if len(foo_get_group.user_ids) > 0 else ""
+    ```
+
 
     :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.
@@ -110,12 +134,9 @@ def get_group(authentication_domain_id: Optional[str] = None,
         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]:
+                     opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = 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.
 
@@ -127,15 +148,43 @@ def get_group_output(authentication_domain_id: Optional[pulumi.Input[str]] = Non
     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,
+    foo = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    foo_get_group = newrelic.get_group(authentication_domain_id=foo.id,
         name="Test Group")
     ```
 
+    ## Additional Examples
+
+    The following example demonstrates utilizing attributes exported by this data source.
+
+    In order to directly reference the attributes `id` and `user_ids` from this data source, you can use the syntax `data.newrelic_group.foo.id` and `data.newrelic_group.foo.user_ids`, respectively. However, if you need to assign these values to local variables and perform further processing (such as conditionally formatting the `user_ids` attribute as shown in the example below), consider using the provided configuration. These variables can then be accessed elsewhere using the syntax `local.id` and `local.user_id`, respectively.
+
+    ```python
+    import pulumi
+    import pulumi_newrelic as newrelic
+    import pulumi_std as std
+
+    foo = newrelic.get_authentication_domain(name="Test Authentication Domain")
+    foo_get_group = newrelic.get_group(authentication_domain_id=foo.id,
+        name="Test Group")
+    id = foo_get_group.id
+    user_ids = std.join(separator=", ",
+        input=foo_get_group.user_ids).result if len(foo_get_group.user_ids) > 0 else ""
+    ```
+
 
     :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.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getGroup:getGroup', __args__, opts=opts, typ=GetGroupResult)
+    return __ret__.apply(lambda __response__: GetGroupResult(
+        authentication_domain_id=pulumi.get(__response__, 'authentication_domain_id'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name'),
+        user_ids=pulumi.get(__response__, 'user_ids')))

pulumi_newrelic/get_key_transaction.py

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
@@ -21,13 +26,46 @@ class GetKeyTransactionResult:
     """
     A collection of values returned by getKeyTransaction.
     """
-    def __init__(__self__, id=None, name=None):
+    def __init__(__self__, account_id=None, domain=None, guid=None, id=None, name=None, type=None):
+        if account_id and not isinstance(account_id, str):
+            raise TypeError("Expected argument 'account_id' to be a str")
+        pulumi.set(__self__, "account_id", account_id)
+        if domain and not isinstance(domain, str):
+            raise TypeError("Expected argument 'domain' to be a str")
+        pulumi.set(__self__, "domain", domain)
+        if guid and not isinstance(guid, str):
+            raise TypeError("Expected argument 'guid' to be a str")
+        pulumi.set(__self__, "guid", guid)
         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 type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="accountId")
+    def account_id(self) -> str:
+        return pulumi.get(self, "account_id")
+
+    @property
+    @pulumi.getter
+    def domain(self) -> str:
+        """
+        Domain of the key transaction in New Relic.
+        """
+        return pulumi.get(self, "domain")
+
+    @property
+    @pulumi.getter
+    def guid(self) -> str:
+        """
+        GUID of the key transaction in New Relic.
+        """
+        return pulumi.get(self, "guid")
 
     @property
     @pulumi.getter
@@ -42,6 +80,14 @@ class GetKeyTransactionResult:
     def name(self) -> str:
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Type of the key transaction in New Relic.
+        """
+        return pulumi.get(self, "type")
+
 
 class AwaitableGetKeyTransactionResult(GetKeyTransactionResult):
     # pylint: disable=using-constant-test
@@ -49,11 +95,17 @@ class AwaitableGetKeyTransactionResult(GetKeyTransactionResult):
         if False:
             yield self
         return GetKeyTransactionResult(
+            account_id=self.account_id,
+            domain=self.domain,
+            guid=self.guid,
             id=self.id,
-            name=self.name)
+            name=self.name,
+            type=self.type)
 
 
-def get_key_transaction(name: Optional[str] = None,
+def get_key_transaction(account_id: Optional[str] = None,
+                        guid: Optional[str] = None,
+                        name: Optional[str] = None,
                         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetKeyTransactionResult:
     """
     Use this data source to get information about a specific key transaction in New Relic that already exists.
@@ -65,38 +117,48 @@ def get_key_transaction(name: Optional[str] = None,
     import pulumi_newrelic as newrelic
 
     txn = newrelic.get_key_transaction(name="txn")
-    foo_alert_policy = newrelic.AlertPolicy("fooAlertPolicy")
-    foo_alert_condition = newrelic.AlertCondition("fooAlertCondition",
-        policy_id=foo_alert_policy.id,
+    foo = newrelic.AlertPolicy("foo", name="foo")
+    foo_alert_condition = newrelic.AlertCondition("foo",
+        policy_id=foo.id,
+        name="foo",
         type="apm_kt_metric",
         entities=[txn.id],
         metric="error_percentage",
         runbook_url="https://www.example.com",
-        terms=[newrelic.AlertConditionTermArgs(
-            duration=5,
-            operator="below",
-            priority="critical",
-            threshold=0.75,
-            time_function="all",
-        )])
+        terms=[{
+            "duration": 5,
+            "operator": "below",
+            "priority": "critical",
+            "threshold": 0.75,
+            "time_function": "all",
+        }])
     ```
 
 
+    :param str account_id: The account ID you would like to search for key transactions in. Defaults to `account_id` in the `provider{}` (or `NEW_RELIC_ACCOUNT_ID` in your environment) if not specified.
+           
+           > **NOTE** If the `name` specified in the configuration matches the names of multiple key transactions in the account, the data source will return the first match from the list of all matching key transactions retrieved from the API. However, when using the `guid` argument as the search criterion, only the key transaction with that particular GUID is returned, as each key transaction has a unique GUID.
+    :param str guid: GUID of the key transaction in New Relic.
     :param str name: The name of the key transaction in New Relic.
     """
     __args__ = dict()
+    __args__['accountId'] = account_id
+    __args__['guid'] = guid
     __args__['name'] = name
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('newrelic:index/getKeyTransaction:getKeyTransaction', __args__, opts=opts, typ=GetKeyTransactionResult).value
 
     return AwaitableGetKeyTransactionResult(
+        account_id=pulumi.get(__ret__, 'account_id'),
+        domain=pulumi.get(__ret__, 'domain'),
+        guid=pulumi.get(__ret__, 'guid'),
         id=pulumi.get(__ret__, 'id'),
-        name=pulumi.get(__ret__, 'name'))
-
-
-@_utilities.lift_output_func(get_key_transaction)
-def get_key_transaction_output(name: Optional[pulumi.Input[str]] = None,
-                               opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetKeyTransactionResult]:
+        name=pulumi.get(__ret__, 'name'),
+        type=pulumi.get(__ret__, 'type'))
+def get_key_transaction_output(account_id: Optional[pulumi.Input[Optional[str]]] = None,
+                               guid: Optional[pulumi.Input[Optional[str]]] = None,
+                               name: Optional[pulumi.Input[str]] = None,
+                               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetKeyTransactionResult]:
     """
     Use this data source to get information about a specific key transaction in New Relic that already exists.
 
@@ -107,23 +169,40 @@ def get_key_transaction_output(name: Optional[pulumi.Input[str]] = None,
     import pulumi_newrelic as newrelic
 
     txn = newrelic.get_key_transaction(name="txn")
-    foo_alert_policy = newrelic.AlertPolicy("fooAlertPolicy")
-    foo_alert_condition = newrelic.AlertCondition("fooAlertCondition",
-        policy_id=foo_alert_policy.id,
+    foo = newrelic.AlertPolicy("foo", name="foo")
+    foo_alert_condition = newrelic.AlertCondition("foo",
+        policy_id=foo.id,
+        name="foo",
         type="apm_kt_metric",
         entities=[txn.id],
         metric="error_percentage",
         runbook_url="https://www.example.com",
-        terms=[newrelic.AlertConditionTermArgs(
-            duration=5,
-            operator="below",
-            priority="critical",
-            threshold=0.75,
-            time_function="all",
-        )])
+        terms=[{
+            "duration": 5,
+            "operator": "below",
+            "priority": "critical",
+            "threshold": 0.75,
+            "time_function": "all",
+        }])
     ```
 
 
+    :param str account_id: The account ID you would like to search for key transactions in. Defaults to `account_id` in the `provider{}` (or `NEW_RELIC_ACCOUNT_ID` in your environment) if not specified.
+           
+           > **NOTE** If the `name` specified in the configuration matches the names of multiple key transactions in the account, the data source will return the first match from the list of all matching key transactions retrieved from the API. However, when using the `guid` argument as the search criterion, only the key transaction with that particular GUID is returned, as each key transaction has a unique GUID.
+    :param str guid: GUID of the key transaction in New Relic.
     :param str name: The name of the key transaction in New Relic.
     """
-    ...
+    __args__ = dict()
+    __args__['accountId'] = account_id
+    __args__['guid'] = guid
+    __args__['name'] = name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getKeyTransaction:getKeyTransaction', __args__, opts=opts, typ=GetKeyTransactionResult)
+    return __ret__.apply(lambda __response__: GetKeyTransactionResult(
+        account_id=pulumi.get(__response__, 'account_id'),
+        domain=pulumi.get(__response__, 'domain'),
+        guid=pulumi.get(__response__, 'guid'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name'),
+        type=pulumi.get(__response__, 'type')))