dagster-cloud 1.12.10__py3-none-any.whl → 1.12.12__py3-none-any.whl

dagster_cloud/agent/dagster_cloud_agent.py

@@ -30,11 +30,8 @@ from dagster._utils.merger import merge_dicts
 from dagster._utils.typed_dict import init_optional_typeddict
 from dagster_cloud_cli.core.errors import DagsterCloudHTTPError, raise_http_error
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData
+from dagster_shared.record import replace
 
-from dagster_cloud.agent.instrumentation.constants import DAGSTER_CLOUD_AGENT_METRIC_PREFIX
-from dagster_cloud.agent.instrumentation.run_launch import extract_run_attributes
-from dagster_cloud.agent.instrumentation.schedule import inspect_schedule_result
-from dagster_cloud.agent.instrumentation.sensor import inspect_sensor_result
 from dagster_cloud.agent.queries import (
     ADD_AGENT_HEARTBEATS_MUTATION,
     DEPLOYMENTS_QUERY,
@@ -58,7 +55,6 @@ from dagster_cloud.api.dagster_cloud_api import (
 )
 from dagster_cloud.batching import Batcher
 from dagster_cloud.instance import DagsterCloudAgentInstance
-from dagster_cloud.opentelemetry.observers.execution_observer import observe_execution
 from dagster_cloud.util import SERVER_HANDLE_TAG, compressed_namedtuple_upload_file, is_isolated_run
 from dagster_cloud.version import __version__
 from dagster_cloud.workspace.user_code_launcher import (
@@ -907,8 +903,9 @@ class DagsterCloudAgent:
                 user_code_launcher, deployment_name, cast("str", location_name)
             )
             serialized_snapshot_or_error = client.execution_plan_snapshot(
-                execution_plan_snapshot_args=request.request_args._replace(
-                    instance_ref=self._get_user_code_instance_ref(deployment_name)
+                execution_plan_snapshot_args=replace(
+                    request.request_args,
+                    instance_ref=self._get_user_code_instance_ref(deployment_name),
                 )
             )
             return DagsterCloudApiGrpcResponse(
@@ -974,64 +971,34 @@ class DagsterCloudAgent:
                 user_code_launcher, deployment_name, cast("str", location_name)
             )
 
-            args = request.request_args._replace(
-                instance_ref=self._get_user_code_instance_ref(deployment_name)
+            args = replace(
+                request.request_args,
+                instance_ref=self._get_user_code_instance_ref(deployment_name),
             )
 
-            schedule_attributes = {
-                "schedule": args.schedule_name,
-                "repository": args.repository_origin.repository_name,
-                "location": args.repository_origin.code_location_origin.location_name,
-                "deployment": deployment_name,
-            }
-
-            with observe_execution(
-                opentelemetry=self._instance.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.schedule.evaluation",
-                short_description="schedule evaluation requests",
-                attributes=schedule_attributes,
-                result_evaluator_callback=inspect_schedule_result,
-            ) as observer:
-                serialized_schedule_data_or_error = client.external_schedule_execution(
-                    external_schedule_execution_args=args,
-                )
-                observer.evaluate_result(
-                    serialized_data_or_error=serialized_schedule_data_or_error,
-                )
-                return DagsterCloudApiGrpcResponse(
-                    serialized_response_or_error=serialized_schedule_data_or_error
-                )
+            serialized_schedule_data_or_error = client.external_schedule_execution(
+                external_schedule_execution_args=args,
+            )
+            return DagsterCloudApiGrpcResponse(
+                serialized_response_or_error=serialized_schedule_data_or_error
+            )
 
         elif api_name == DagsterCloudApi.GET_EXTERNAL_SENSOR_EXECUTION_DATA:
             client = self._get_grpc_client(
                 user_code_launcher, deployment_name, cast("str", location_name)
             )
 
-            args = request.request_args._replace(
-                instance_ref=self._get_user_code_instance_ref(deployment_name)
+            args = replace(
+                request.request_args,
+                instance_ref=self._get_user_code_instance_ref(deployment_name),
             )
 
-            sensor_attributes = {
-                "sensor": args.sensor_name,
-                "repository": args.repository_origin.repository_name,
-                "location": args.repository_origin.code_location_origin.location_name,
-                "deployment": deployment_name,
-            }
-
-            with observe_execution(
-                opentelemetry=self._instance.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.sensor.evaluation",
-                short_description="sensor evaluation requests",
-                attributes=sensor_attributes,
-                result_evaluator_callback=inspect_sensor_result,
-            ) as observer:
-                serialized_sensor_data_or_error = client.external_sensor_execution(
-                    sensor_execution_args=args,
-                )
-                observer.evaluate_result(serialized_sensor_data_or_error)
-                return DagsterCloudApiGrpcResponse(
-                    serialized_response_or_error=serialized_sensor_data_or_error
-                )
+            serialized_sensor_data_or_error = client.external_sensor_execution(
+                sensor_execution_args=args,
+            )
+            return DagsterCloudApiGrpcResponse(
+                serialized_response_or_error=serialized_sensor_data_or_error
+            )
         elif api_name == DagsterCloudApi.GET_EXTERNAL_NOTEBOOK_DATA:
             client = self._get_grpc_client(
                 user_code_launcher, deployment_name, cast("str", location_name)
@@ -1062,42 +1029,32 @@ class DagsterCloudAgent:
                     ),
                 )
 
-                run_attributes = extract_run_attributes(deployment_name, run)
-                with observe_execution(
-                    opentelemetry=self._instance.opentelemetry,
-                    event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.run.launches",
-                    short_description="run execution requests",
-                    attributes=run_attributes,
-                ) as observer:
-                    launcher = scoped_instance.get_run_launcher_for_run(run)  # type: ignore  # (instance subclass)
+                launcher = scoped_instance.get_run_launcher_for_run(run)  # type: ignore  # (instance subclass)
 
-                    if is_isolated_run(run):
-                        launcher.launch_run(LaunchRunContext(dagster_run=run, workspace=None))
-                    else:
-                        scoped_instance.report_engine_event(
-                            f"Launching {run.run_id} without an isolated run environment.",
-                            run,
-                            cls=self.__class__,
-                        )
+                if is_isolated_run(run):
+                    launcher.launch_run(LaunchRunContext(dagster_run=run, workspace=None))
+                else:
+                    scoped_instance.report_engine_event(
+                        f"Launching {run.run_id} without an isolated run environment.",
+                        run,
+                        cls=self.__class__,
+                    )
 
-                        run_location_name = cast(
-                            "str",
-                            run.remote_job_origin.repository_origin.code_location_origin.location_name,
-                        )
+                    run_location_name = cast(
+                        "str",
+                        run.remote_job_origin.repository_origin.code_location_origin.location_name,
+                    )
 
-                        server = user_code_launcher.get_grpc_server(
-                            deployment_name, run_location_name
-                        )
+                    server = user_code_launcher.get_grpc_server(deployment_name, run_location_name)
 
-                        # Record the server handle that we launched it on to for run monitoring
-                        scoped_instance.add_run_tags(
-                            run.run_id, new_tags={SERVER_HANDLE_TAG: str(server.server_handle)}
-                        )
+                    # Record the server handle that we launched it on to for run monitoring
+                    scoped_instance.add_run_tags(
+                        run.run_id, new_tags={SERVER_HANDLE_TAG: str(server.server_handle)}
+                    )
 
-                        launcher.launch_run_from_grpc_client(
-                            scoped_instance, run, server.server_endpoint.create_client()
-                        )
-                    observer.evaluate_result(run=run)
+                    launcher.launch_run_from_grpc_client(
+                        scoped_instance, run, server.server_endpoint.create_client()
+                    )
 
                 return DagsterCloudApiSuccess()
         elif api_name == DagsterCloudApi.TERMINATE_RUN:

dagster_cloud/instance/__init__.py

@@ -1,7 +1,7 @@
 import copy
 import socket
 import uuid
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from contextlib import ExitStack
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Optional, Union
@@ -34,11 +34,8 @@ from urllib3 import Retry
 
 from dagster_cloud.agent import AgentQueuesConfig
 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
@@ -83,7 +80,6 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         allowed_full_deployment_locations=None,
         allowed_branch_deployment_locations=None,
         agent_metrics=None,
-        opentelemetry=None,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
@@ -155,12 +151,6 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
             allowed_branch_deployment_locations
         )
 
-        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
@@ -582,9 +572,6 @@ instance_class:
                 is_required=False,
                 description="List of allowed location names for branch deployments",
             ),
-            "opentelemetry": Field(
-                opentelemetry_config_schema(), is_required=False, default_value={"enabled": False}
-            ),
         }
 
     @classmethod
@@ -667,9 +654,6 @@ instance_class:
 
     def dispose(self) -> None:
         super().dispose()
-        if self._opentelemetry_controller:
-            self._opentelemetry_controller.dispose()
-            self._opentelemetry_controller = None
         self._exit_stack.close()
 
     @property
@@ -690,17 +674,6 @@ 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/pex/grpc/server/manager.py

@@ -16,7 +16,7 @@ from dagster._utils.error import SerializableErrorInfo, serializable_error_info_
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData, PexMetadata
 from dagster_shared import seven
 from dagster_shared.ipc import open_ipc_subprocess
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel
 
 from dagster_cloud.pex.grpc.server.registry import PexS3Registry
 from dagster_cloud.pex.grpc.types import PexServerHandle
@@ -25,7 +25,7 @@ from dagster_cloud.workspace.user_code_launcher.utils import get_grpc_server_env
 logger = logging.getLogger("dagster.multipex")
 
 
-class PexProcessEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_types_allowed=True):
+class PexProcessEntry(BaseModel, frozen=True, extra="forbid", arbitrary_types_allowed=True):
     pex_server_handle: PexServerHandle
     grpc_server_process: subprocess.Popen
     grpc_client: DagsterGrpcClient
@@ -33,7 +33,7 @@ class PexProcessEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_type
     heartbeat_thread: threading.Thread
 
 
-class PexErrorEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_types_allowed=True):
+class PexErrorEntry(BaseModel, frozen=True, extra="forbid", arbitrary_types_allowed=True):
     pex_server_handle: PexServerHandle
     error: SerializableErrorInfo
 

dagster_cloud/version.py

@@ -1 +1 @@
-__version__ = "1.12.10"
+__version__ = "1.12.12"

dagster_cloud/workspace/docker/__init__.py

@@ -40,6 +40,7 @@ from dagster_cloud.workspace.user_code_launcher import (
 from dagster_cloud.workspace.user_code_launcher.user_code_launcher import UserCodeLauncherEntry
 from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location,
+    get_code_server_port,
     get_grpc_server_env,
 )
 
@@ -293,7 +294,7 @@ class DockerUserCodeLauncher(
 
         has_network = len(self._networks) > 0
         if has_network:
-            grpc_port = 4000
+            grpc_port = get_code_server_port()
             hostname = container_name
         else:
             grpc_port = find_free_port()

dagster_cloud/workspace/ecs/client.py

@@ -17,7 +17,7 @@ from dagster_aws.ecs.utils import is_transient_task_stopped_reason, task_definit
 
 from dagster_cloud.workspace.ecs.service import Service
 
-DEFAULT_ECS_TIMEOUT = 300
+DEFAULT_ECS_TIMEOUT = 600
 DEFAULT_ECS_GRACE_PERIOD = 30
 
 STOPPED_TASK_GRACE_PERIOD = 30

dagster_cloud/workspace/ecs/launcher.py

@@ -53,13 +53,13 @@ from dagster_cloud.workspace.user_code_launcher.user_code_launcher import (
 )
 from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location,
+    get_code_server_port,
     get_grpc_server_env,
 )
 
 EcsServerHandleType = Service
 
 CONTAINER_NAME = "dagster"
-PORT = 4000
 
 
 class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], ConfigurableClass):
@@ -405,7 +405,8 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
 
         if metadata.pex_metadata:
             command = metadata.get_multipex_server_command(
-                PORT, metrics_enabled=self._instance.user_code_launcher.code_server_metrics_enabled
+                get_code_server_port(),
+                metrics_enabled=self._instance.user_code_launcher.code_server_metrics_enabled,
             )
             additional_env = metadata.get_multipex_server_env()
             tags = {
@@ -418,7 +419,10 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
                 metrics_enabled=self._instance.user_code_launcher.code_server_metrics_enabled
             )
             additional_env = get_grpc_server_env(
-                metadata, PORT, location_name, self._instance.ref_for_deployment(deployment_name)
+                metadata,
+                get_code_server_port(),
+                location_name,
+                self._instance.ref_for_deployment(deployment_name),
             )
             tags = {
                 "dagster/grpc_server": "1",
@@ -524,7 +528,7 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
 
         endpoint = ServerEndpoint(
             host=service.hostname,
-            port=PORT,
+            port=get_code_server_port(),
             socket=None,
         )
 

dagster_cloud/workspace/kubernetes/launcher.py

@@ -34,7 +34,6 @@ from dagster_cloud.constants import RESERVED_ENV_VAR_NAMES
 from dagster_cloud.execution.cloud_run_launcher.k8s import CloudK8sRunLauncher
 from dagster_cloud.execution.monitoring import CloudContainerResourceLimits
 from dagster_cloud.workspace.kubernetes.utils import (
-    SERVICE_PORT,
     construct_code_location_deployment,
     construct_code_location_service,
     get_deployment_failure_debug_info,
@@ -49,7 +48,10 @@ from dagster_cloud.workspace.user_code_launcher import (
     ServerEndpoint,
     UserCodeLauncherEntry,
 )
-from dagster_cloud.workspace.user_code_launcher.utils import deterministic_label_for_location
+from dagster_cloud.workspace.user_code_launcher.utils import (
+    deterministic_label_for_location,
+    get_code_server_port,
+)
 
 DEFAULT_DEPLOYMENT_STARTUP_TIMEOUT = 300
 DEFAULT_IMAGE_PULL_GRACE_PERIOD = 30
@@ -506,7 +508,7 @@ class K8sUserCodeLauncher(DagsterCloudUserCodeLauncher[K8sHandle], ConfigurableC
 
         endpoint = ServerEndpoint(
             host=host,
-            port=SERVICE_PORT,
+            port=get_code_server_port(),
             socket=None,
         )
 

dagster_cloud/workspace/kubernetes/utils.py

@@ -13,13 +13,13 @@ from kubernetes import client
 from dagster_cloud.instance import DagsterCloudAgentInstance
 from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location,
+    get_code_server_port,
     get_grpc_server_env,
     get_human_readable_label,
     unique_resource_name,
 )
 
 MANAGED_RESOURCES_LABEL = {"managed_by": "K8sUserCodeLauncher"}
-SERVICE_PORT = 4000
 
 
 def _get_dagster_k8s_labels(
@@ -106,7 +106,7 @@ def construct_code_location_service(
             },
             "spec": {
                 "selector": {"user-deployment": service_name},
-                "ports": [{"name": "grpc", "protocol": "TCP", "port": SERVICE_PORT}],
+                "ports": [{"name": "grpc", "protocol": "TCP", "port": get_code_server_port()}],
             },
         },
     )
@@ -123,7 +123,10 @@ def construct_code_location_deployment(
     server_timestamp: float,
 ):
     env = get_grpc_server_env(
-        metadata, SERVICE_PORT, location_name, instance.ref_for_deployment(deployment_name)
+        metadata,
+        get_code_server_port(),
+        location_name,
+        instance.ref_for_deployment(deployment_name),
     )
 
     user_defined_config = container_context.server_k8s_config

dagster_cloud/workspace/user_code_launcher/user_code_launcher.py

@@ -56,7 +56,6 @@ from dagster_cloud_cli.core.errors import raise_http_error
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData
 from typing_extensions import Self, TypeAlias
 
-from dagster_cloud.agent.instrumentation.constants import DAGSTER_CLOUD_AGENT_METRIC_PREFIX
 from dagster_cloud.agent.queries import GET_AGENTS_QUERY
 from dagster_cloud.api.dagster_cloud_api import (
     CheckSnapshotResult,
@@ -85,8 +84,6 @@ from dagster_cloud.execution.monitoring import (
     start_run_worker_monitoring_thread,
 )
 from dagster_cloud.instance import DagsterCloudAgentInstance
-from dagster_cloud.opentelemetry.controller import OpenTelemetryController
-from dagster_cloud.opentelemetry.observers.execution_observer import observe_execution
 from dagster_cloud.pex.grpc.client import MultiPexGrpcClient
 from dagster_cloud.pex.grpc.types import (
     CreatePexServerArgs,
@@ -1125,11 +1122,6 @@ class DagsterCloudUserCodeLauncher(
     ):
         deployment_name, location_name = to_update_key
 
-        attributes = {
-            "deployment": deployment_name,
-            "location": location_name,
-        }
-
         code_location_deploy_data = desired_entry.code_location_deploy_data
         pex_metadata = code_location_deploy_data.pex_metadata
         deployment_info = (
@@ -1142,19 +1134,13 @@ class DagsterCloudUserCodeLauncher(
                 self._logger.info(
                     f"Waiting for new grpc server for {deployment_name}:{location_name} for {deployment_info} to be ready..."
                 )
-                with observe_execution(
-                    opentelemetry=self.opentelemetry,
-                    event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.server.process_wait",
-                    short_description="waiting for new server process to be ready",
-                    attributes=attributes,
-                ):
-                    await self._wait_for_new_server_ready(
-                        deployment_name,
-                        location_name,
-                        desired_entry,
-                        server_or_error.server_handle,
-                        server_or_error.server_endpoint,
-                    )
+                await self._wait_for_new_server_ready(
+                    deployment_name,
+                    location_name,
+                    desired_entry,
+                    server_or_error.server_handle,
+                    server_or_error.server_endpoint,
+                )
             except Exception:
                 error_info = serializable_error_info_from_exc_info(sys.exc_info())
                 self._logger.error(
@@ -1164,18 +1150,12 @@ class DagsterCloudUserCodeLauncher(
                 server_or_error = error_info
 
         if should_upload:
-            with observe_execution(
-                opentelemetry=self.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.upload",
-                short_description="uploading user code data",
-                attributes=attributes,
-            ):
-                await self._try_update_location_data(
-                    deployment_name,
-                    location_name,
-                    server_or_error,
-                    desired_entry.code_location_deploy_data,
-                )
+            await self._try_update_location_data(
+                deployment_name,
+                location_name,
+                server_or_error,
+                desired_entry.code_location_deploy_data,
+            )
 
         # Once we've verified that the new server has uploaded its data successfully, swap in
         # the server to start serving new requests
@@ -1558,7 +1538,7 @@ class DagsterCloudUserCodeLauncher(
             del self._multipex_servers[deployment_location]
 
     def _refresh_actual_entries(self) -> None:
-        for deployment_location, multipex_server in self._multipex_servers.items():
+        for deployment_location, multipex_server in self._multipex_servers.copy().items():
             if deployment_location in self._actual_entries:
                 # If a multipex server exists, we query it over gRPC
                 # to make sure the pex server is still available.
@@ -1836,28 +1816,16 @@ class DagsterCloudUserCodeLauncher(
                         # confirm it's a valid image since _start_new_server_spinup will launch a container
                         self._check_for_image(desired_entry.code_location_deploy_data)
 
-                        attributes = {
-                            "deployment": deployment_name,
-                            "location": location_name,
-                            "image": desired_entry.code_location_deploy_data.image,
-                            "python_version": desired_python_version,
-                        }
-                        with observe_execution(
-                            opentelemetry=self.opentelemetry,
-                            event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.multipex_server.start",
-                            short_description="starting new multipex server",
-                            attributes=attributes,
-                        ):
-                            multipex_server = self._start_new_server_spinup(
-                                deployment_name, location_name, desired_entry
-                            )
-                            self._multipex_servers[to_update_key] = multipex_server
-                            assert self._get_multipex_server(
-                                deployment_name,
-                                location_name,
-                                desired_entry.code_location_deploy_data,
-                            )
-                            new_multipex_servers[to_update_key] = multipex_server
+                        multipex_server = self._start_new_server_spinup(
+                            deployment_name, location_name, desired_entry
+                        )
+                        self._multipex_servers[to_update_key] = multipex_server
+                        assert self._get_multipex_server(
+                            deployment_name,
+                            location_name,
+                            desired_entry.code_location_deploy_data,
+                        )
+                        new_multipex_servers[to_update_key] = multipex_server
                     else:
                         self._logger.info(
                             f"Found running multipex server for {multipex_server_repr}"
@@ -2173,11 +2141,6 @@ class DagsterCloudUserCodeLauncher(
     def _start_new_dagster_server(
         self, deployment_name: str, location_name: str, desired_entry: UserCodeLauncherEntry
     ) -> DagsterCloudGrpcServer:
-        attributes = {
-            "deployment": deployment_name,
-            "location": location_name,
-        }
-
         if desired_entry.code_location_deploy_data.pex_metadata:
             multipex_server = self._get_multipex_server(
                 deployment_name, location_name, desired_entry.code_location_deploy_data
@@ -2185,45 +2148,26 @@ class DagsterCloudUserCodeLauncher(
 
             assert multipex_server  # should have been started earlier or we should never reach here
 
-            if desired_entry.code_location_deploy_data.pex_metadata.python_version:
-                attributes["python_version"] = (
-                    desired_entry.code_location_deploy_data.pex_metadata.python_version
-                )
+            self._create_pex_server(deployment_name, location_name, desired_entry, multipex_server)
 
-            with observe_execution(
-                opentelemetry=self.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.pex_server.start",
-                short_description="starting new pex server",
-                attributes=attributes,
-            ):
-                self._create_pex_server(
-                    deployment_name, location_name, desired_entry, multipex_server
-                )
+            server_handle = multipex_server.server_handle
+            multipex_endpoint = multipex_server.server_endpoint
 
-                server_handle = multipex_server.server_handle
-                multipex_endpoint = multipex_server.server_endpoint
-
-                # start a new pex server on the multipexer, which we can count on already existing
-                return DagsterCloudGrpcServer(
-                    server_handle,
-                    multipex_endpoint.with_metadata(
-                        [
-                            ("has_pex", "1"),
-                            ("deployment", deployment_name),
-                            ("location", location_name),
-                            ("timestamp", str(int(desired_entry.update_timestamp))),
-                        ],
-                    ),
-                    desired_entry.code_location_deploy_data,
-                )
+            # start a new pex server on the multipexer, which we can count on already existing
+            return DagsterCloudGrpcServer(
+                server_handle,
+                multipex_endpoint.with_metadata(
+                    [
+                        ("has_pex", "1"),
+                        ("deployment", deployment_name),
+                        ("location", location_name),
+                        ("timestamp", str(int(desired_entry.update_timestamp))),
+                    ],
+                ),
+                desired_entry.code_location_deploy_data,
+            )
         else:
-            with observe_execution(
-                opentelemetry=self.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.code_server.start",
-                short_description="new code server spin up",
-                attributes=attributes,
-            ):
-                return self._start_new_server_spinup(deployment_name, location_name, desired_entry)
+            return self._start_new_server_spinup(deployment_name, location_name, desired_entry)
 
     def get_grpc_endpoint(
         self,
@@ -2443,13 +2387,6 @@ class DagsterCloudUserCodeLauncher(
                 )
                 return response
 
-    @property
-    def opentelemetry(self) -> Optional[OpenTelemetryController]:
-        if not self.has_instance:
-            return None
-        else:
-            return self._instance.opentelemetry
-
     def upload_job_snap_direct(
         self,
         deployment_name: str,