pulumi-oci 3.4.0a1755714728__py3-none-any.whl → 3.5.0__py3-none-any.whl

pulumi_oci/apmtraces/__init__.py

@@ -6,9 +6,14 @@ import builtins as _builtins
 from .. import _utilities
 import typing
 # Export this package's modules as members:
+from .get_attribute_auto_activate_status import *
+from .get_log import *
 from .get_query_quick_picks import *
+from .get_scheduled_queries import *
+from .get_scheduled_query import *
 from .get_trace import *
 from .get_trace_aggregated_snapshot_data import *
 from .get_trace_snapshot_data import *
+from .scheduled_query import *
 from ._inputs import *
 from . import outputs

pulumi_oci/apmtraces/_inputs.py

@@ -15,12 +15,369 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'ScheduledQueryScheduledQueryProcessingConfigurationArgs',
+    'ScheduledQueryScheduledQueryProcessingConfigurationArgsDict',
+    'ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgs',
+    'ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgsDict',
+    'ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgs',
+    'ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgsDict',
+    'ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgs',
+    'ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgsDict',
     'GetQueryQuickPicksFilterArgs',
     'GetQueryQuickPicksFilterArgsDict',
+    'GetScheduledQueriesFilterArgs',
+    'GetScheduledQueriesFilterArgsDict',
 ]
 
 MYPY = False
 
+if not MYPY:
+    class ScheduledQueryScheduledQueryProcessingConfigurationArgsDict(TypedDict):
+        custom_metric: NotRequired[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgsDict']]
+        """
+        (Updatable) Definition of the Custom Metric.
+        """
+        object_storage: NotRequired[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgsDict']]
+        """
+        (Updatable) Definition of the object storage.
+        """
+        streaming: NotRequired[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgsDict']]
+        """
+        (Updatable) Definition of the Stream.
+        """
+elif False:
+    ScheduledQueryScheduledQueryProcessingConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ScheduledQueryScheduledQueryProcessingConfigurationArgs:
+    def __init__(__self__, *,
+                 custom_metric: Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgs']] = None,
+                 object_storage: Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgs']] = None,
+                 streaming: Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgs']] = None):
+        """
+        :param pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgs'] custom_metric: (Updatable) Definition of the Custom Metric.
+        :param pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgs'] object_storage: (Updatable) Definition of the object storage.
+        :param pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgs'] streaming: (Updatable) Definition of the Stream.
+        """
+        if custom_metric is not None:
+            pulumi.set(__self__, "custom_metric", custom_metric)
+        if object_storage is not None:
+            pulumi.set(__self__, "object_storage", object_storage)
+        if streaming is not None:
+            pulumi.set(__self__, "streaming", streaming)
+
+    @_builtins.property
+    @pulumi.getter(name="customMetric")
+    def custom_metric(self) -> Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgs']]:
+        """
+        (Updatable) Definition of the Custom Metric.
+        """
+        return pulumi.get(self, "custom_metric")
+
+    @custom_metric.setter
+    def custom_metric(self, value: Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgs']]):
+        pulumi.set(self, "custom_metric", value)
+
+    @_builtins.property
+    @pulumi.getter(name="objectStorage")
+    def object_storage(self) -> Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgs']]:
+        """
+        (Updatable) Definition of the object storage.
+        """
+        return pulumi.get(self, "object_storage")
+
+    @object_storage.setter
+    def object_storage(self, value: Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgs']]):
+        pulumi.set(self, "object_storage", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def streaming(self) -> Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgs']]:
+        """
+        (Updatable) Definition of the Stream.
+        """
+        return pulumi.get(self, "streaming")
+
+    @streaming.setter
+    def streaming(self, value: Optional[pulumi.Input['ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgs']]):
+        pulumi.set(self, "streaming", value)
+
+
+if not MYPY:
+    class ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgsDict(TypedDict):
+        name: pulumi.Input[_builtins.str]
+        """
+        (Updatable) Name of the Custom Metric.
+        """
+        compartment: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Compartment of the Monitoring Service. It defaults to the APM domain's compartment if not specified.  If specified, the necessary Oracle Cloud Infrastructure policies should be set to allow APM to write to that compartment.
+        """
+        description: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Description of the Custom Metric.
+        """
+        is_anomaly_detection_enabled: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        (Updatable) Indicates whether anomaly Detection should be performed on the generated metric.
+        """
+        is_metric_published: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        (Updatable) Used in conjunction with the dry run header.  When the dry run header is set and the isPublishMetric flag is set to true, the  scheduled query is not created, but validations happen to check if the right Oracle Cloud Infrastructure policies have been set to write to the specified namespace/compartment.
+        """
+        namespace: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Namespace in the Custom Metric. It defaults to `oracle_apm_custom` if not specified.  If specified, the necessary Oracle Cloud Infrastructure policies should be set to allow APM to write to that namespace.
+        """
+        resource_group: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Resource Group of the Custom Metric.
+        """
+        unit: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Unit in which the metric value is reported. For example 'ms'.
+        """
+elif False:
+    ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ScheduledQueryScheduledQueryProcessingConfigurationCustomMetricArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[_builtins.str],
+                 compartment: Optional[pulumi.Input[_builtins.str]] = None,
+                 description: Optional[pulumi.Input[_builtins.str]] = None,
+                 is_anomaly_detection_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
+                 is_metric_published: Optional[pulumi.Input[_builtins.bool]] = None,
+                 namespace: Optional[pulumi.Input[_builtins.str]] = None,
+                 resource_group: Optional[pulumi.Input[_builtins.str]] = None,
+                 unit: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] name: (Updatable) Name of the Custom Metric.
+        :param pulumi.Input[_builtins.str] compartment: (Updatable) Compartment of the Monitoring Service. It defaults to the APM domain's compartment if not specified.  If specified, the necessary Oracle Cloud Infrastructure policies should be set to allow APM to write to that compartment.
+        :param pulumi.Input[_builtins.str] description: (Updatable) Description of the Custom Metric.
+        :param pulumi.Input[_builtins.bool] is_anomaly_detection_enabled: (Updatable) Indicates whether anomaly Detection should be performed on the generated metric.
+        :param pulumi.Input[_builtins.bool] is_metric_published: (Updatable) Used in conjunction with the dry run header.  When the dry run header is set and the isPublishMetric flag is set to true, the  scheduled query is not created, but validations happen to check if the right Oracle Cloud Infrastructure policies have been set to write to the specified namespace/compartment.
+        :param pulumi.Input[_builtins.str] namespace: (Updatable) Namespace in the Custom Metric. It defaults to `oracle_apm_custom` if not specified.  If specified, the necessary Oracle Cloud Infrastructure policies should be set to allow APM to write to that namespace.
+        :param pulumi.Input[_builtins.str] resource_group: (Updatable) Resource Group of the Custom Metric.
+        :param pulumi.Input[_builtins.str] unit: (Updatable) Unit in which the metric value is reported. For example 'ms'.
+        """
+        pulumi.set(__self__, "name", name)
+        if compartment is not None:
+            pulumi.set(__self__, "compartment", compartment)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if is_anomaly_detection_enabled is not None:
+            pulumi.set(__self__, "is_anomaly_detection_enabled", is_anomaly_detection_enabled)
+        if is_metric_published is not None:
+            pulumi.set(__self__, "is_metric_published", is_metric_published)
+        if namespace is not None:
+            pulumi.set(__self__, "namespace", namespace)
+        if resource_group is not None:
+            pulumi.set(__self__, "resource_group", resource_group)
+        if unit is not None:
+            pulumi.set(__self__, "unit", unit)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[_builtins.str]:
+        """
+        (Updatable) Name of the Custom Metric.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def compartment(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Compartment of the Monitoring Service. It defaults to the APM domain's compartment if not specified.  If specified, the necessary Oracle Cloud Infrastructure policies should be set to allow APM to write to that compartment.
+        """
+        return pulumi.get(self, "compartment")
+
+    @compartment.setter
+    def compartment(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "compartment", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Description of the Custom Metric.
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "description", value)
+
+    @_builtins.property
+    @pulumi.getter(name="isAnomalyDetectionEnabled")
+    def is_anomaly_detection_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        (Updatable) Indicates whether anomaly Detection should be performed on the generated metric.
+        """
+        return pulumi.get(self, "is_anomaly_detection_enabled")
+
+    @is_anomaly_detection_enabled.setter
+    def is_anomaly_detection_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "is_anomaly_detection_enabled", value)
+
+    @_builtins.property
+    @pulumi.getter(name="isMetricPublished")
+    def is_metric_published(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        (Updatable) Used in conjunction with the dry run header.  When the dry run header is set and the isPublishMetric flag is set to true, the  scheduled query is not created, but validations happen to check if the right Oracle Cloud Infrastructure policies have been set to write to the specified namespace/compartment.
+        """
+        return pulumi.get(self, "is_metric_published")
+
+    @is_metric_published.setter
+    def is_metric_published(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "is_metric_published", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Namespace in the Custom Metric. It defaults to `oracle_apm_custom` if not specified.  If specified, the necessary Oracle Cloud Infrastructure policies should be set to allow APM to write to that namespace.
+        """
+        return pulumi.get(self, "namespace")
+
+    @namespace.setter
+    def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "namespace", value)
+
+    @_builtins.property
+    @pulumi.getter(name="resourceGroup")
+    def resource_group(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Resource Group of the Custom Metric.
+        """
+        return pulumi.get(self, "resource_group")
+
+    @resource_group.setter
+    def resource_group(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "resource_group", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def unit(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Unit in which the metric value is reported. For example 'ms'.
+        """
+        return pulumi.get(self, "unit")
+
+    @unit.setter
+    def unit(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "unit", value)
+
+
+if not MYPY:
+    class ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgsDict(TypedDict):
+        bucket: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Bucket name in the object store.
+        """
+        name_space: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Namespace in the object store.
+        """
+        object_name_prefix: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Object name prefix in the object store.
+        """
+elif False:
+    ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ScheduledQueryScheduledQueryProcessingConfigurationObjectStorageArgs:
+    def __init__(__self__, *,
+                 bucket: Optional[pulumi.Input[_builtins.str]] = None,
+                 name_space: Optional[pulumi.Input[_builtins.str]] = None,
+                 object_name_prefix: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] bucket: (Updatable) Bucket name in the object store.
+        :param pulumi.Input[_builtins.str] name_space: (Updatable) Namespace in the object store.
+        :param pulumi.Input[_builtins.str] object_name_prefix: (Updatable) Object name prefix in the object store.
+        """
+        if bucket is not None:
+            pulumi.set(__self__, "bucket", bucket)
+        if name_space is not None:
+            pulumi.set(__self__, "name_space", name_space)
+        if object_name_prefix is not None:
+            pulumi.set(__self__, "object_name_prefix", object_name_prefix)
+
+    @_builtins.property
+    @pulumi.getter
+    def bucket(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Bucket name in the object store.
+        """
+        return pulumi.get(self, "bucket")
+
+    @bucket.setter
+    def bucket(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "bucket", value)
+
+    @_builtins.property
+    @pulumi.getter(name="nameSpace")
+    def name_space(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Namespace in the object store.
+        """
+        return pulumi.get(self, "name_space")
+
+    @name_space.setter
+    def name_space(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "name_space", value)
+
+    @_builtins.property
+    @pulumi.getter(name="objectNamePrefix")
+    def object_name_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Object name prefix in the object store.
+        """
+        return pulumi.get(self, "object_name_prefix")
+
+    @object_name_prefix.setter
+    def object_name_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "object_name_prefix", value)
+
+
+if not MYPY:
+    class ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgsDict(TypedDict):
+        stream_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Updatable) Stream Id.
+        """
+elif False:
+    ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ScheduledQueryScheduledQueryProcessingConfigurationStreamingArgs:
+    def __init__(__self__, *,
+                 stream_id: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] stream_id: (Updatable) Stream Id.
+        """
+        if stream_id is not None:
+            pulumi.set(__self__, "stream_id", stream_id)
+
+    @_builtins.property
+    @pulumi.getter(name="streamId")
+    def stream_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Updatable) Stream Id.
+        """
+        return pulumi.get(self, "stream_id")
+
+    @stream_id.setter
+    def stream_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "stream_id", value)
+
+
 if not MYPY:
     class GetQueryQuickPicksFilterArgsDict(TypedDict):
         name: _builtins.str
@@ -68,3 +425,59 @@ class GetQueryQuickPicksFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetScheduledQueriesFilterArgsDict(TypedDict):
+        name: _builtins.str
+        """
+        Name of the Custom Metric.
+        """
+        values: Sequence[_builtins.str]
+        regex: NotRequired[_builtins.bool]
+elif False:
+    GetScheduledQueriesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetScheduledQueriesFilterArgs:
+    def __init__(__self__, *,
+                 name: _builtins.str,
+                 values: Sequence[_builtins.str],
+                 regex: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str name: Name of the Custom Metric.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "values", values)
+        if regex is not None:
+            pulumi.set(__self__, "regex", regex)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        Name of the Custom Metric.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: _builtins.str):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def values(self) -> Sequence[_builtins.str]:
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: Sequence[_builtins.str]):
+        pulumi.set(self, "values", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def regex(self) -> Optional[_builtins.bool]:
+        return pulumi.get(self, "regex")
+
+    @regex.setter
+    def regex(self, value: Optional[_builtins.bool]):
+        pulumi.set(self, "regex", value)
+
+

pulumi_oci/apmtraces/get_attribute_auto_activate_status.py

@@ -0,0 +1,160 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'GetAttributeAutoActivateStatusResult',
+    'AwaitableGetAttributeAutoActivateStatusResult',
+    'get_attribute_auto_activate_status',
+    'get_attribute_auto_activate_status_output',
+]
+
+@pulumi.output_type
+class GetAttributeAutoActivateStatusResult:
+    """
+    A collection of values returned by getAttributeAutoActivateStatus.
+    """
+    def __init__(__self__, apm_domain_id=None, data_key=None, data_key_type=None, id=None, state=None):
+        if apm_domain_id and not isinstance(apm_domain_id, str):
+            raise TypeError("Expected argument 'apm_domain_id' to be a str")
+        pulumi.set(__self__, "apm_domain_id", apm_domain_id)
+        if data_key and not isinstance(data_key, str):
+            raise TypeError("Expected argument 'data_key' to be a str")
+        pulumi.set(__self__, "data_key", data_key)
+        if data_key_type and not isinstance(data_key_type, str):
+            raise TypeError("Expected argument 'data_key_type' to be a str")
+        pulumi.set(__self__, "data_key_type", data_key_type)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if state and not isinstance(state, str):
+            raise TypeError("Expected argument 'state' to be a str")
+        pulumi.set(__self__, "state", state)
+
+    @_builtins.property
+    @pulumi.getter(name="apmDomainId")
+    def apm_domain_id(self) -> _builtins.str:
+        return pulumi.get(self, "apm_domain_id")
+
+    @_builtins.property
+    @pulumi.getter(name="dataKey")
+    def data_key(self) -> _builtins.str:
+        """
+        Data key type for which auto-activate needs needs to be turned on or off.
+        """
+        return pulumi.get(self, "data_key")
+
+    @_builtins.property
+    @pulumi.getter(name="dataKeyType")
+    def data_key_type(self) -> _builtins.str:
+        return pulumi.get(self, "data_key_type")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def state(self) -> _builtins.str:
+        """
+        State of autoactivation in this APM Domain.  If "ON" auto-activate is set to true, if "OFF" auto-activate is set to false.
+        """
+        return pulumi.get(self, "state")
+
+
+class AwaitableGetAttributeAutoActivateStatusResult(GetAttributeAutoActivateStatusResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetAttributeAutoActivateStatusResult(
+            apm_domain_id=self.apm_domain_id,
+            data_key=self.data_key,
+            data_key_type=self.data_key_type,
+            id=self.id,
+            state=self.state)
+
+
+def get_attribute_auto_activate_status(apm_domain_id: Optional[_builtins.str] = None,
+                                       data_key_type: Optional[_builtins.str] = None,
+                                       opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAttributeAutoActivateStatusResult:
+    """
+    This data source provides details about a specific Attribute Auto Activate Status resource in Oracle Cloud Infrastructure Apm Traces service.
+
+    Get autoactivation status for a private data key or public data key in the APM Domain.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_attribute_auto_activate_status = oci.ApmTraces.get_attribute_auto_activate_status(apm_domain_id=test_apm_domain["id"],
+        data_key_type=attribute_auto_activate_status_data_key_type)
+    ```
+
+
+    :param _builtins.str apm_domain_id: The APM Domain ID for the intended request.
+    :param _builtins.str data_key_type: Data key type for which auto-activate needs to be turned on or off.
+    """
+    __args__ = dict()
+    __args__['apmDomainId'] = apm_domain_id
+    __args__['dataKeyType'] = data_key_type
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('oci:ApmTraces/getAttributeAutoActivateStatus:getAttributeAutoActivateStatus', __args__, opts=opts, typ=GetAttributeAutoActivateStatusResult).value
+
+    return AwaitableGetAttributeAutoActivateStatusResult(
+        apm_domain_id=pulumi.get(__ret__, 'apm_domain_id'),
+        data_key=pulumi.get(__ret__, 'data_key'),
+        data_key_type=pulumi.get(__ret__, 'data_key_type'),
+        id=pulumi.get(__ret__, 'id'),
+        state=pulumi.get(__ret__, 'state'))
+def get_attribute_auto_activate_status_output(apm_domain_id: Optional[pulumi.Input[_builtins.str]] = None,
+                                              data_key_type: Optional[pulumi.Input[_builtins.str]] = None,
+                                              opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetAttributeAutoActivateStatusResult]:
+    """
+    This data source provides details about a specific Attribute Auto Activate Status resource in Oracle Cloud Infrastructure Apm Traces service.
+
+    Get autoactivation status for a private data key or public data key in the APM Domain.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_attribute_auto_activate_status = oci.ApmTraces.get_attribute_auto_activate_status(apm_domain_id=test_apm_domain["id"],
+        data_key_type=attribute_auto_activate_status_data_key_type)
+    ```
+
+
+    :param _builtins.str apm_domain_id: The APM Domain ID for the intended request.
+    :param _builtins.str data_key_type: Data key type for which auto-activate needs to be turned on or off.
+    """
+    __args__ = dict()
+    __args__['apmDomainId'] = apm_domain_id
+    __args__['dataKeyType'] = data_key_type
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('oci:ApmTraces/getAttributeAutoActivateStatus:getAttributeAutoActivateStatus', __args__, opts=opts, typ=GetAttributeAutoActivateStatusResult)
+    return __ret__.apply(lambda __response__: GetAttributeAutoActivateStatusResult(
+        apm_domain_id=pulumi.get(__response__, 'apm_domain_id'),
+        data_key=pulumi.get(__response__, 'data_key'),
+        data_key_type=pulumi.get(__response__, 'data_key_type'),
+        id=pulumi.get(__response__, 'id'),
+        state=pulumi.get(__response__, 'state')))