dagster-cloud 1.8.2__py3-none-any.whl → 1.12.6__py3-none-any.whl

dagster_cloud/instance/__init__.py

@@ -1,9 +1,10 @@
 import copy
 import socket
 import uuid
+from collections.abc import Mapping, Sequence
 from contextlib import ExitStack
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import yaml
 from dagster import (
@@ -19,6 +20,7 @@ from dagster._core.instance.config import config_field_for_configurable_class
 from dagster._core.instance.ref import InstanceRef, configurable_class_data
 from dagster._core.launcher import DefaultRunLauncher, RunLauncher
 from dagster._core.storage.dagster_run import DagsterRun
+from dagster._core.storage.defs_state.base import DefsStateStorage
 from dagster._serdes import ConfigurableClassData
 from dagster_cloud_cli.core.graphql_client import (
     create_agent_graphql_client,
@@ -30,10 +32,12 @@ from dagster_cloud_cli.core.headers.auth import DagsterCloudInstanceScope
 from urllib3 import Retry
 
 from dagster_cloud.agent import AgentQueuesConfig
-
-from ..auth.constants import get_organization_name_from_agent_token
-from ..storage.client import dagster_cloud_api_config
-from ..util import get_env_names_from_config, is_isolated_run
+from dagster_cloud.auth.constants import decode_agent_token
+from dagster_cloud.opentelemetry.config import opentelemetry_config_schema
+from dagster_cloud.opentelemetry.controller import OpenTelemetryController
+from dagster_cloud.storage.client import dagster_cloud_api_config
+from dagster_cloud.util import get_env_names_from_config, is_isolated_run
+from dagster_cloud.version import __version__
 
 if TYPE_CHECKING:
     from requests import Session
@@ -48,6 +52,23 @@ class DagsterCloudInstance(DagsterInstance):
     def telemetry_enabled(self) -> bool:
         return False
 
+    @property
+    def run_retries_max_retries(self) -> int:
+        raise NotImplementedError(
+            "run_retries.max_retries is a deployment setting and can only be accessed by a DeploymentScopedHostInstance"
+        )
+
+    @property
+    def run_retries_retry_on_asset_or_op_failure(self) -> bool:
+        raise NotImplementedError(
+            "run_retries.retry_on_asset_or_op_failure is a deployment setting and can only be accessed by a DeploymentScopedHostInstance"
+        )
+
+    @property
+    def defs_state_storage(self) -> Optional[DefsStateStorage]:
+        # only DeploymentScopedHostInstance / DagsterCloudAgentInstance have a defs state storage
+        return None
+
 
 class DagsterCloudAgentInstance(DagsterCloudInstance):
     def __init__(
@@ -59,13 +80,18 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         isolated_agents=None,
         agent_queues=None,
         agent_metrics=None,
+        opentelemetry=None,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
 
         self._unprocessed_dagster_cloud_api_config = dagster_cloud_api
-        self._dagster_cloud_api_config = self._get_processed_config(
-            "dagster_cloud_api", dagster_cloud_api, dagster_cloud_api_config()
+        self._dagster_cloud_api_config = check.not_none(
+            self._get_processed_config(
+                "dagster_cloud_api",
+                dagster_cloud_api,
+                dagster_cloud_api_config(),
+            )
         )
 
         check.invariant(
@@ -117,12 +143,29 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         processed_agent_queues_config = self._get_processed_config(
             "agent_queues", agent_queues, self._agent_queues_config_schema()
         )
-        self.agent_queues_config = AgentQueuesConfig(**processed_agent_queues_config)
+        self.agent_queues_config = AgentQueuesConfig(**processed_agent_queues_config)  # pyright: ignore[reportCallIssue]
+
+        self._opentelemetry_config: Optional[Mapping[str, Any]] = self._get_processed_config(
+            "opentelemetry", opentelemetry, opentelemetry_config_schema()
+        )
+
+        self._opentelemetry_controller: Optional[OpenTelemetryController] = None
 
         self._instance_uuid = str(uuid.uuid4())
 
+    @property
+    def defs_state_storage(self) -> Optional[DefsStateStorage]:
+        # temporary hack to avoid cases where the default BlobStorageStateStorage is used
+        from dagster_cloud.storage.defs_state.storage import GraphQLDefsStateStorage
+
+        return (
+            self._defs_state_storage
+            if isinstance(self._defs_state_storage, GraphQLDefsStateStorage)
+            else None
+        )
+
     def _get_processed_config(
-        self, name: str, config: Optional[Dict[str, Any]], config_type: Dict[str, Any]
+        self, name: str, config: Optional[dict[str, Any]], config_type: dict[str, Any]
     ):
         config_dict = check.opt_dict_param(config, "config", key_type=str)
         processed_config = process_config(config_type, config_dict)
@@ -140,15 +183,11 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
             new_api_config["deployment"] = deployment_name
             if self.includes_branch_deployments:
                 del new_api_config["branch_deployments"]
-            if "deployments" in new_api_config:
-                del new_api_config["deployments"]
-            if "all_serverless_deployments" in new_api_config:
-                del new_api_config["all_serverless_deployments"]
+            new_api_config.pop("deployments", None)
+            new_api_config.pop("all_serverless_deployments", None)
         else:
-            if "deployment" in new_api_config:
-                del new_api_config["deployment"]
-            if "deployments" in new_api_config:
-                del new_api_config["deployments"]
+            new_api_config.pop("deployment", None)
+            new_api_config.pop("deployments", None)
 
         return new_api_config
 
@@ -187,7 +226,7 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         return create_agent_graphql_client(
             self.client_managed_retries_requests_session,
             self.dagster_cloud_graphql_url,
-            self._dagster_cloud_api_config,
+            self._dagster_cloud_api_config,  # pyright: ignore[reportArgumentType]
             scope=scope,
         )
 
@@ -270,7 +309,7 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         if self._http_client is None:
             self._http_client = create_agent_http_client(
                 self.client_managed_retries_requests_session,
-                self._dagster_cloud_api_config,
+                self._dagster_cloud_api_config,  # pyright: ignore[reportArgumentType]
                 scope=DagsterCloudInstanceScope.DEPLOYMENT,
             )
 
@@ -281,18 +320,23 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         if "url" in self._dagster_cloud_api_config:
             return self._dagster_cloud_api_config["url"]
 
-        organization = get_organization_name_from_agent_token(self.dagster_cloud_agent_token)
+        organization, region = decode_agent_token(self.dagster_cloud_agent_token)
         if not organization:
             raise DagsterInvariantViolationError(
                 "Could not derive Dagster Cloud URL from agent token. Create a new agent token or"
                 " set the `url` field under `dagster_cloud_api` in your `dagster.yaml`."
             )
 
-        return f"https://{organization}.agent.dagster.cloud"
+        return (
+            f"https://{organization}.agent.{region}.dagster.cloud"
+            if region
+            else f"https://{organization}.agent.dagster.cloud"
+        )
 
     @property
     def organization_name(self) -> Optional[str]:
-        return get_organization_name_from_agent_token(self.dagster_cloud_agent_token)
+        organization, _ = decode_agent_token(self.dagster_cloud_agent_token)
+        return organization
 
     @property
     def deployment_name(self) -> Optional[str]:
@@ -306,7 +350,7 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         return deployment_names[0]
 
     @property
-    def deployment_names(self) -> List[str]:
+    def deployment_names(self) -> list[str]:
         if self._dagster_cloud_api_config.get("deployment"):
             return [self._dagster_cloud_api_config["deployment"]]
 
@@ -314,11 +358,11 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
 
     @property
     def include_all_serverless_deployments(self) -> bool:
-        return self._dagster_cloud_api_config.get("all_serverless_deployments")
+        return self._dagster_cloud_api_config.get("all_serverless_deployments") or False
 
     @property
     def dagit_url(self):
-        organization = get_organization_name_from_agent_token(self.dagster_cloud_agent_token)
+        organization, region = decode_agent_token(self.dagster_cloud_agent_token)
         if not organization:
             raise Exception(
                 "Could not derive Dagster Cloud URL from agent token to generate a Dagit URL."
@@ -326,7 +370,12 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
             )
 
         deployment = self._dagster_cloud_api_config.get("deployment")
-        return f"https://{organization}.dagster.cloud/" + (f"{deployment}/" if deployment else "")
+        base_url = (
+            f"https://{organization}.{region}.dagster.cloud/"
+            if region
+            else f"https://{organization}.dagster.cloud/"
+        )
+        return base_url + (f"{deployment}/" if deployment else "")
 
     @property
     def dagster_cloud_graphql_url(self):
@@ -360,12 +409,29 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
     def dagster_cloud_upload_api_response_url(self):
         return f"{self.dagster_cloud_url}/upload_api_response"
 
+    @property
+    def dagster_cloud_check_snapshot_url(self):
+        return f"{self.dagster_cloud_url}/check_snapshot"
+
+    @property
+    def dagster_cloud_confirm_upload_url(self):
+        return f"{self.dagster_cloud_url}/confirm_upload"
+
+    @property
+    def dagster_cloud_code_location_update_result_url(self):
+        return f"{self.dagster_cloud_url}/code_location_update_result"
+
     def dagster_cloud_api_headers(self, scope: DagsterCloudInstanceScope):
-        return get_agent_headers(self._dagster_cloud_api_config, scope=scope)
+        return get_agent_headers(self._dagster_cloud_api_config, scope=scope)  # pyright: ignore[reportArgumentType]
 
     @property
-    def dagster_cloud_agent_token(self):
-        return self._dagster_cloud_api_config.get("agent_token")
+    def dagster_cloud_agent_token(self) -> str:
+        check.invariant(
+            self._dagster_cloud_api_config.get("agent_token") is not None,
+            "No agent token found in dagster_cloud_api configuration. An agent token is required"
+            " for Dagster Cloud authentication.",
+        )
+        return self._dagster_cloud_api_config["agent_token"]
 
     @property
     def dagster_cloud_api_retries(self) -> int:
@@ -376,10 +442,10 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         return self._dagster_cloud_api_config["timeout"]
 
     @property
-    def dagster_cloud_api_proxies(self) -> Optional[Dict[str, str]]:
+    def dagster_cloud_api_proxies(self) -> Optional[dict[str, str]]:
         # Requests library modifies the proxies key so create a copy
         return (
-            self._dagster_cloud_api_config.get("proxies").copy()
+            self._dagster_cloud_api_config.get("proxies").copy()  # pyright: ignore[reportOptionalMemberAccess]
             if self._dagster_cloud_api_config.get("proxies")
             else {}
         )
@@ -404,7 +470,7 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
             return f"Agent {self.instance_uuid[:8]}"
 
     @property
-    def dagster_cloud_api_env_vars(self) -> List[str]:
+    def dagster_cloud_api_env_vars(self) -> list[str]:
         return get_env_names_from_config(
             dagster_cloud_api_config(), self._unprocessed_dagster_cloud_api_config
         )
@@ -470,6 +536,9 @@ instance_class:
                 cls._isolated_agents_config_schema(), is_required=False
             ),  # deprecated in favor of isolated_agents
             "agent_queues": Field(cls._agent_queues_config_schema(), is_required=False),
+            "opentelemetry": Field(
+                opentelemetry_config_schema(), is_required=False, default_value={"enabled": False}
+            ),
         }
 
     @classmethod
@@ -496,22 +565,22 @@ instance_class:
 
         empty_yaml = yaml.dump({})
 
-        defaults["run_storage"] = ConfigurableClassData(
+        defaults["run_storage"] = ConfigurableClassData(  # pyright: ignore[reportIndexIssue]
             "dagster_cloud.storage.runs",
             "GraphQLRunStorage",
             empty_yaml,
         )
-        defaults["event_log_storage"] = ConfigurableClassData(
+        defaults["event_log_storage"] = ConfigurableClassData(  # pyright: ignore[reportIndexIssue]
             "dagster_cloud.storage.event_logs",
             "GraphQLEventLogStorage",
             empty_yaml,
         )
-        defaults["schedule_storage"] = ConfigurableClassData(
+        defaults["schedule_storage"] = ConfigurableClassData(  # pyright: ignore[reportIndexIssue]
             "dagster_cloud.storage.schedules",
             "GraphQLScheduleStorage",
             empty_yaml,
         )
-        defaults["storage"] = ConfigurableClassData(
+        defaults["storage"] = ConfigurableClassData(  # pyright: ignore[reportIndexIssue]
             module_name="dagster.core.storage.legacy_storage",
             class_name="CompositeStorage",
             config_yaml=yaml.dump(
@@ -536,18 +605,25 @@ instance_class:
             ),
         )
 
-        defaults["compute_logs"] = ConfigurableClassData(
+        defaults["compute_logs"] = ConfigurableClassData(  # pyright: ignore[reportIndexIssue]
             "dagster_cloud.storage.compute_logs", "CloudComputeLogManager", empty_yaml
         )
 
-        defaults["secrets"] = ConfigurableClassData(
+        defaults["secrets"] = ConfigurableClassData(  # pyright: ignore[reportIndexIssue]
             "dagster_cloud.secrets", "DagsterCloudSecretsLoader", empty_yaml
         )
 
+        defaults["defs_state_storage"] = ConfigurableClassData(  # pyright: ignore[reportIndexIssue]
+            "dagster_cloud.storage.defs_state", "GraphQLDefsStateStorage", empty_yaml
+        )
+
         return defaults
 
     def dispose(self) -> None:
         super().dispose()
+        if self._opentelemetry_controller:
+            self._opentelemetry_controller.dispose()
+            self._opentelemetry_controller = None
         self._exit_stack.close()
 
     @property
@@ -568,6 +644,17 @@ instance_class:
         # potentially overridden interval in the serverless user code launcher
         return 30
 
+    @property
+    def opentelemetry(self) -> OpenTelemetryController:
+        if not self._opentelemetry_controller:
+            self._opentelemetry_controller = OpenTelemetryController(
+                instance_id=self.instance_uuid,
+                version=__version__,
+                config=self._opentelemetry_config,
+            )
+
+        return self._opentelemetry_controller
+
 
 @lru_cache(maxsize=100)  # Scales on order of active branch deployments
 def _cached_inject_deployment(

dagster_cloud/instrumentation/__init__.py

@@ -0,0 +1,32 @@
+from collections.abc import Generator
+from contextlib import AbstractContextManager, contextmanager
+from typing import Optional, Protocol
+
+
+class Instrumentation(Protocol):
+    def tags(self, tags: list[str]) -> "Instrumentation": ...
+
+    def histogram(self, name: str, value: float) -> None: ...
+
+    def increment(self, name: str) -> None: ...
+
+    def instrument_context(
+        self, name: str, buckets_ms: Optional[list[int]]
+    ) -> AbstractContextManager[None]: ...
+
+
+class NoOpInstrumentation(Instrumentation):
+    def tags(self, tags: list[str]) -> Instrumentation:
+        return self
+
+    def histogram(self, name: str, value: float) -> None:
+        pass
+
+    def increment(self, name: str) -> None:
+        pass
+
+    @contextmanager
+    def instrument_context(
+        self, name: str, buckets_ms: Optional[list[int]]
+    ) -> Generator[None, None, None]:
+        yield

dagster_cloud/metadata/source_code.py

@@ -1,9 +1,10 @@
 import os
+from collections.abc import Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from dagster import DagsterInvariantViolationError
-from dagster._annotations import experimental
+from dagster._annotations import beta
 from dagster._core.definitions.metadata import (
     AnchorBasedFilePathMapping,
     link_code_references_to_git,
@@ -12,8 +13,10 @@ from dagster._core.definitions.metadata.source_code import FilePathMapping
 from dagster._core.types.loadable_target_origin import LoadableTargetOrigin
 
 if TYPE_CHECKING:
-    from dagster import AssetsDefinition, SourceAsset
-    from dagster._core.definitions.cacheable_assets import CacheableAssetsDefinition
+    from dagster import AssetsDefinition, AssetSpec, SourceAsset
+    from dagster._core.definitions.assets.definition.cacheable_assets_definition import (
+        CacheableAssetsDefinition,
+    )
 
 import sys
 
@@ -33,7 +36,7 @@ def _locate_git_root() -> Optional[Path]:
     elif code_origin.python_file:
         code_origin_filepath = code_origin.python_file
 
-    if not code_origin_filepath:
+    if not code_origin_filepath:  # pyright: ignore[reportPossiblyUnboundVariable]
         return None
     current_dir = Path(code_origin_filepath)
     for parent in current_dir.parents:
@@ -42,13 +45,15 @@ def _locate_git_root() -> Optional[Path]:
     return None
 
 
-@experimental
+@beta
 def link_code_references_to_git_if_cloud(
-    assets_defs: Sequence[Union["AssetsDefinition", "SourceAsset", "CacheableAssetsDefinition"]],
+    assets_defs: Sequence[
+        Union["AssetsDefinition", "SourceAsset", "CacheableAssetsDefinition", "AssetSpec"]
+    ],
     git_url: Optional[str] = None,
     git_branch: Optional[str] = None,
     file_path_mapping: Optional[FilePathMapping] = None,
-) -> Sequence[Union["AssetsDefinition", "SourceAsset", "CacheableAssetsDefinition"]]:
+) -> Sequence[Union["AssetsDefinition", "SourceAsset", "CacheableAssetsDefinition", "AssetSpec"]]:
     """Wrapper function which converts local file path code references to hosted git URLs
     if running in a Dagster Plus cloud environment. This is determined by the presence of
     the `DAGSTER_CLOUD_DEPLOYMENT_NAME` environment variable. When running in any other context,

dagster_cloud/metrics/tracer.py

@@ -0,0 +1,59 @@
+import base64
+import json
+import time
+from contextlib import contextmanager
+from typing import Optional, Union
+
+# A minimal copy of the standard OTEL API
+
+
+class Span:
+    def __init__(self, name: str):
+        self._name = name
+        self._attrs = {}
+        self._start_time = time.time()
+        self._end_time = None
+
+    def set_attribute(self, key: str, value: Union[int, str]):
+        self._attrs[key] = value
+
+    def end(self):
+        self._end_time = time.time()
+
+    def get_serialized(self) -> str:
+        # base64 to make it safe for a http header (no newlines, few special chars)
+        return base64.b64encode(
+            json.dumps(
+                {
+                    "_name": self._name,
+                    "_duration": self._end_time - self._start_time
+                    if self._end_time is not None
+                    else None,
+                    **self._attrs,
+                },
+                separators=(",", ":"),
+                indent=None,
+            ).encode("utf-8")
+        ).decode()
+
+
+class Tracer:
+    def __init__(self):
+        self._spans: list[Span] = []
+
+    @contextmanager
+    def start_span(self, name: str):
+        span = Span(name)
+        try:
+            yield span
+        finally:
+            span.end()
+            self._spans.append(span)
+
+    def pop_serialized_span(self) -> Optional[str]:
+        try:
+            span = self._spans.pop(0)
+        except IndexError:
+            return None
+        else:
+            return span.get_serialized()

dagster_cloud/opentelemetry/config/__init__.py

@@ -0,0 +1,73 @@
+from dagster import BoolSource, Field, Shape, StringSource
+
+from dagster_cloud.opentelemetry.config.exporter import exporter_config_schema
+from dagster_cloud.opentelemetry.config.log_record_processor import log_record_processor_schema
+from dagster_cloud.opentelemetry.config.logging_handler import logging_handler_schema
+from dagster_cloud.opentelemetry.config.meter_provider import meter_provider_config_schema
+from dagster_cloud.opentelemetry.config.metric_reader import metric_reader_config_schema
+
+
+def opentelemetry_config_schema():
+    return {
+        "enabled": Field(
+            BoolSource,
+            description="Enables OpenTelemetry instrumentation.",
+            is_required=False,
+            default_value=True,
+        ),
+        "service_name": Field(
+            StringSource,
+            description="Name of the service to which to send telemetry",
+            is_required=False,
+            default_value="dagster-cloud-agent",
+        ),
+        "logging": Field(
+            description="The logging configuration.",
+            is_required=False,
+            config=Shape(
+                fields={
+                    "enabled": Field(
+                        BoolSource,
+                        description="Enables logging instrumentation.",
+                        is_required=False,
+                        default_value=False,
+                    ),
+                    "exporter": exporter_config_schema("logging"),
+                    "processor": log_record_processor_schema(),
+                    "handler": logging_handler_schema(),
+                },
+            ),
+        ),
+        "metrics": Field(
+            description="The metrics configuration.",
+            is_required=False,
+            config=Shape(
+                fields={
+                    "enabled": Field(
+                        BoolSource,
+                        description="Enables metrics instrumentation.",
+                        is_required=False,
+                        default_value=False,
+                    ),
+                    "exporter": exporter_config_schema("metrics"),
+                    "reader": metric_reader_config_schema(),
+                    "provider": meter_provider_config_schema(),
+                },
+            ),
+        ),
+        # TODO: Add tracing configuration when it's supported.
+        # "tracing": Field(
+        #     description="The tracing configuration.",
+        #     config=Shape(
+        #         fields={
+        #             "enabled": Field(
+        #                 BoolSource,
+        #                 description="Enables tracing instrumentation.",
+        #                 is_required=False,
+        #                 default_value=False,
+        #             ),
+        #             "exporter": exporter_config_schema("tracing"),
+        #         },
+        #     ),
+        # ),
+    }

dagster_cloud/opentelemetry/config/exporter.py

@@ -0,0 +1,81 @@
+from dagster import BoolSource, Enum, Field, IntSource, Map, Permissive, Shape, StringSource
+
+from dagster_cloud.opentelemetry.enum import (
+    AggregationTemporalityEnum,
+    CompressionEnum,
+    LoggingExporterEnum,
+    MetricsExporterEnum,
+    MetricsInstrumentTypesEnum,
+    TracingExporterEnum,
+    ViewAggregationEnum,
+)
+
+# Convert Python to Dagster enums
+compression_enum = Enum.from_python_enum_direct_values(CompressionEnum)
+logging_exporter_enum = Enum.from_python_enum_direct_values(LoggingExporterEnum)
+metrics_exporter_enum = Enum.from_python_enum_direct_values(MetricsExporterEnum)
+tracing_exporter_enum = Enum.from_python_enum_direct_values(TracingExporterEnum)
+
+aggregation_temporality_enum = Enum.from_python_enum_direct_values(AggregationTemporalityEnum)
+metrics_instrument_types_enum = Enum.from_python_enum_direct_values(MetricsInstrumentTypesEnum)
+view_aggregation_enum = Enum.from_python_enum_direct_values(ViewAggregationEnum)
+
+
+def exporter_config_schema(pillar: str) -> Shape:
+    """Different observability pillars have different supported exporters but share common parameters.
+    Valid pillars are: logging, metrics, tracing.
+    """
+    exporter_type_field: Field
+    exporter_extra_params: dict = {}
+    if pillar == "logging":
+        exporter_type_field = Field(
+            config=logging_exporter_enum,
+            is_required=False,
+            default_value=LoggingExporterEnum.ConsoleLogExporter.value,
+        )
+    elif pillar == "metrics":
+        exporter_type_field = Field(
+            config=metrics_exporter_enum,
+            is_required=False,
+            default_value=MetricsExporterEnum.ConsoleMetricExporter.value,
+        )
+        exporter_extra_params = {
+            "preferred_temporality": Field(
+                config=Map(str, aggregation_temporality_enum), is_required=False
+            ),
+            "preferred_aggregation": Field(
+                config=Map(str, view_aggregation_enum), is_required=False
+            ),
+        }
+    elif pillar == "tracing":
+        exporter_type_field = Field(
+            config=tracing_exporter_enum,
+        )
+    else:
+        raise ValueError(f"Invalid pillar: {pillar}")
+
+    return Shape(
+        description="Provide configuration for an OpenTelemetry exporter.",
+        fields={
+            "type": exporter_type_field,
+            "params": Permissive(
+                fields={
+                    # These fields are common to most exporters. No defaults are provided, to allow either
+                    # OpenTelemetry's default or environment variables to be used.
+                    # Ref: https://opentelemetry-python.readthedocs.io/en/latest/sdk/environment_variables.html
+                    "endpoint": Field(StringSource, is_required=False),
+                    "compression": Field(config=compression_enum, is_required=False),
+                    "headers": Field(
+                        description="Custom headers to send", config=Permissive(), is_required=False
+                    ),
+                    "certificate_file": Field(StringSource, is_required=False),
+                    "client_key_file": Field(StringSource, is_required=False),
+                    "client_certificate_file": Field(StringSource, is_required=False),
+                    "insecure": Field(BoolSource, is_required=False),
+                    "timeout": Field(IntSource, is_required=False),
+                    # These fields are specific an exporter.
+                    **exporter_extra_params,
+                }
+            ),
+        },
+    )