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

dagster_cloud/opentelemetry/factories/metrics.py

@@ -0,0 +1,121 @@
+from typing import Optional
+
+from opentelemetry.metrics import MeterProvider as APIMeterProvider
+from opentelemetry.sdk.metrics.export import MetricExporter, MetricReader
+
+from dagster_cloud.opentelemetry.config.exporter import metrics_instrument_types_enum
+from dagster_cloud.opentelemetry.enum import MetricsExporterEnum, MetricsReaderEnum
+
+
+def _validate_dict_keys_as_metric_instruments(src: dict, dict_name: str) -> None:
+    """Validate that all keys in a dictionary are valid metric instrument types."""
+    for key in src:
+        if key not in metrics_instrument_types_enum.enum_values:
+            raise ValueError(
+                f"OpenTelemetry configuration error - Invalid instrument type '{key}' in {dict_name}."
+            )
+
+
+def build_metric_exporter(exporter_config: dict) -> MetricExporter:
+    """Build an OpenTelemetry metric exporter.
+    params:
+        exporter: dict: The exporter configuration.
+          - type: str: The exporter type.
+          - params: dict: The exporter parameters (varies).
+
+    Returns:
+        MetricExporter: The metric exporter instance.
+    """
+    exporter_type = exporter_config.get("type", MetricsExporterEnum.ConsoleMetricExporter.value)
+    exporter_params = exporter_config.get("params", {})
+
+    if "preferred_temporality" in exporter_params:
+        _validate_dict_keys_as_metric_instruments(
+            exporter_params["preferred_temporality"], "preferred_temporality"
+        )
+
+    if "preferred_aggregation" in exporter_params:
+        _validate_dict_keys_as_metric_instruments(
+            exporter_params["preferred_aggregation"], "preferred_aggregation"
+        )
+
+    if exporter_type == MetricsExporterEnum.HttpProtoOTLPExporter.value:
+        from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+
+        return OTLPMetricExporter(**exporter_params)
+    elif exporter_type == MetricsExporterEnum.GrpcProtoOTLPExporter.value:
+        from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
+
+        return OTLPMetricExporter(**exporter_params)
+    elif exporter_type == MetricsExporterEnum.ConsoleMetricExporter.value:
+        from opentelemetry.sdk.metrics.export import ConsoleMetricExporter
+
+        return ConsoleMetricExporter(**exporter_params)
+
+    raise ValueError(f"Invalid exporter type: {exporter_type}")
+
+
+def build_metric_reader(
+    exporter: Optional[MetricExporter] = None, reader_config: Optional[dict] = None
+) -> MetricReader:
+    """Build an OpenTelemetry metric reader.
+    params:
+        reader: dict: The reader configuration.
+
+    Returns:
+        MetricReader: The metric reader instance.
+    """
+    reader_config = reader_config or {}
+    reader_type = reader_config.get("type", MetricsReaderEnum.PeriodicExportingMetricReader.value)
+    reader_params = reader_config.get("params", {})
+
+    if reader_type == MetricsReaderEnum.PeriodicExportingMetricReader.value:
+        from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+
+        if exporter is None:
+            raise ValueError("Exporter is required for PeriodicExportingMetricReader.")
+        return PeriodicExportingMetricReader(exporter=exporter, **reader_params)
+    elif reader_type == MetricsReaderEnum.InMemoryMetricReader.value:
+        from opentelemetry.sdk.metrics.export import InMemoryMetricReader
+
+        return InMemoryMetricReader(**reader_params)
+
+    raise ValueError(f"Invalid metric reader type: {reader_type}")
+
+
+def build_meter_provider(
+    metric_readers: list[MetricReader],
+    resource_attributes: Optional[dict[str, str]] = None,
+) -> APIMeterProvider:
+    """Build an OpenTelemetry meter provider.
+    params:
+        metric_reader: MetricReader: The metric reader instance.
+        resource: Resource (optional): The resource instance.
+
+    Returns:
+        MeterProvider: The meter provider instance.
+    """
+    from opentelemetry.sdk.metrics import MeterProvider
+    from opentelemetry.sdk.resources import Resource
+
+    resource = (
+        Resource.create(attributes=resource_attributes)
+        if resource_attributes
+        else Resource.create({})
+    )
+
+    return MeterProvider(
+        metric_readers=metric_readers,
+        resource=resource,
+        shutdown_on_exit=False,
+        # TODO - implement support for views?
+        # https://opentelemetry-python.readthedocs.io/en/latest/_modules/opentelemetry/sdk/metrics/_internal/view.html#View
+        # views=views,
+    )
+
+
+def build_noop_meter_provider() -> APIMeterProvider:
+    """Build a no-op OpenTelemetry meter provider."""
+    from opentelemetry.metrics import NoOpMeterProvider
+
+    return NoOpMeterProvider()

dagster_cloud/opentelemetry/metrics/meter.py

@@ -0,0 +1,140 @@
+from collections.abc import Generator, Iterable, Sequence
+from typing import Callable, Optional, Union, cast
+
+# (Gauge is only exposed as a private class)
+from opentelemetry.metrics import (
+    CallbackOptions,
+    Counter,
+    Histogram,
+    Instrument,
+    ObservableCounter,
+    ObservableGauge,
+    ObservableUpDownCounter,
+    Observation,
+    UpDownCounter,
+)
+from opentelemetry.metrics._internal import Meter as SDKMeter
+
+InstrumentKeyType = tuple[str, str, str]
+ObservableCallback = Callable[[CallbackOptions], Iterable[Observation]]
+ObservableGenerator = Generator[Iterable[Observation], CallbackOptions, None]
+ObserverType = Union[ObservableCallback, ObservableGenerator]
+
+
+class Meter:
+    def __init__(self, meter: SDKMeter):
+        self._meter = meter
+        self._instruments: dict[InstrumentKeyType, Instrument] = {}
+
+    @property
+    def name(self) -> str:
+        return self._meter.name
+
+    @property
+    def version(self) -> Optional[str]:
+        return self._meter.version
+
+    @property
+    def schema_url(self) -> Optional[str]:
+        return self._meter.schema_url
+
+    def get_counter(self, name: str, description: str = "", unit: str = "") -> Counter:
+        key = (name, description, unit)
+        instrument = self._instruments.get(key)
+        if not instrument:
+            instrument = self._meter.create_counter(
+                name=name,
+                description=description,
+                unit=unit,
+            )
+            self._instruments[key] = instrument
+
+        return cast("Counter", instrument)
+
+    def get_up_down_counter(
+        self, name: str, description: str = "", unit: str = ""
+    ) -> UpDownCounter:
+        key = (name, description, unit)
+        instrument = self._instruments.get(key)
+        if not instrument:
+            instrument = self._meter.create_up_down_counter(
+                name=name,
+                description=description,
+                unit=unit,
+            )
+            self._instruments[key] = instrument
+
+        return cast("UpDownCounter", instrument)
+
+    def get_histogram(self, name: str, description: str = "", unit: str = "") -> Histogram:
+        key = (name, description, unit)
+        instrument = self._instruments.get(key)
+        if not instrument:
+            instrument = self._meter.create_histogram(
+                name=name,
+                description=description,
+                unit=unit,
+            )
+            self._instruments[key] = instrument
+
+        return cast("Histogram", instrument)
+
+    def get_observable_counter(
+        self,
+        name: str,
+        description: str = "",
+        unit: str = "",
+        observers: Optional[Sequence[ObserverType]] = None,
+    ) -> ObservableCounter:
+        key = (name, description, unit)
+        instrument = self._instruments.get(key)
+        if not instrument:
+            instrument = self._meter.create_observable_counter(
+                name=name,
+                description=description,
+                unit=unit,
+                callbacks=observers,
+            )
+            self._instruments[key] = instrument
+
+        return cast("ObservableCounter", instrument)
+
+    def get_observable_up_down_counter(
+        self,
+        name: str,
+        description: str = "",
+        unit: str = "",
+        observers: Optional[Sequence[ObserverType]] = None,
+    ) -> ObservableUpDownCounter:
+        key = (name, description, unit)
+        instrument = self._instruments.get(key)
+        if not instrument:
+            instrument = self._meter.create_observable_up_down_counter(
+                name=name,
+                description=description,
+                unit=unit,
+                callbacks=observers,
+            )
+            self._instruments[key] = instrument
+
+        return cast("ObservableUpDownCounter", instrument)
+
+    def get_observable_gauge(
+        self,
+        name: str,
+        description: str = "",
+        unit: str = "",
+        observers: Optional[Sequence[ObserverType]] = None,
+    ) -> ObservableGauge:
+        key = (name, description, unit)
+        instrument = self._instruments.get(key)
+        if not instrument:
+            instrument = self._meter.create_observable_gauge(
+                name=name,
+                description=description,
+                unit=unit,
+                callbacks=observers,
+            )
+            self._instruments[key] = instrument
+
+        return cast("ObservableGauge", instrument)

dagster_cloud/opentelemetry/observers/dagster_exception_handler.py

@@ -0,0 +1,40 @@
+from dagster import DagsterError
+from dagster._utils.error import SerializableErrorInfo
+from grpc import Call as GrpcCall
+
+
+def extract_dagster_error_attributes(error: DagsterError) -> dict[str, str]:
+    """Extracts attributes from a DagsterError that can be used for logging or metrics."""
+    error_attributes = {
+        "exception": type(error).__name__,
+    }
+
+    # DagsterError subtypes often have a field that contains a SerializableErrorInfo object
+    # which identify the cause of the error. This field names vary between error types and is not
+    # always present, but if they are they often identify the root cause of the error.
+    for field in dir(error):
+        if field.startswith("__"):
+            # Skip magic methods and fields
+            continue
+
+        attr = getattr(error, field)
+        if type(attr) is list and all(isinstance(item, SerializableErrorInfo) for item in attr):
+            serializable_error_infos: list[SerializableErrorInfo] = getattr(error, field)
+            for serializable_error_info in serializable_error_infos:
+                if serializable_error_info.cause and serializable_error_info.cause.cls_name:
+                    error_attributes["cause"] = serializable_error_info.cause.cls_name
+                    return error_attributes
+
+    # If not obtained from SerializableErrorInfo, use __cause__ to determine the error attributes
+    if hasattr(error, "__cause__") and error.__cause__:
+        error_cause = error.__cause__
+        cause_name = type(error_cause).__name__
+        if cause_name:
+            error_attributes["cause"] = cause_name
+
+        if isinstance(error_cause, GrpcCall):
+            grpc_call: GrpcCall = error_cause
+            code = grpc_call.code()
+            error_attributes["code"] = code.name
+
+    return error_attributes

dagster_cloud/opentelemetry/observers/execution_observer.py

@@ -0,0 +1,178 @@
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from typing import Callable, Optional
+
+from dagster import DagsterError
+from dagster._time import get_current_timestamp
+
+from dagster_cloud.opentelemetry.controller import OpenTelemetryController
+from dagster_cloud.opentelemetry.observers.dagster_exception_handler import (
+    extract_dagster_error_attributes,
+)
+
+ResultEvaluatorCallback = Callable[..., str]
+
+
+class ExecutionObserverInstruments:
+    """OpenTelemetry instruments used to record generic code block executions."""
+
+    def __init__(
+        self, opentelemetry: OpenTelemetryController, metric_base_name: str, description: str
+    ):
+        self._meter = opentelemetry.get_meter(
+            name=metric_base_name,
+            attributes={
+                "description": description,
+            },
+        )
+
+        self._executions = self._meter.get_counter(
+            name=metric_base_name,
+            description=f"Number of {description}",
+        )
+
+        self._completions = self._meter.get_counter(
+            name=f"{metric_base_name}.completions",
+            description=f"Number of {description} completions by status",
+        )
+
+        self._exceptions = self._meter.get_counter(
+            name=f"{metric_base_name}.exceptions",
+            description=f"Number of exceptions caught in {description}",
+        )
+
+        self._duration = self._meter.get_histogram(
+            name=f"{metric_base_name}.duration",
+            description=f"Duration of {description}",
+            unit="seconds",
+        )
+
+    @property
+    def meter(self):
+        """Get the OpenTelemetry meter. This is useful for adding custom metrics."""
+        return self._meter
+
+    @property
+    def executions(self):
+        """Get the OpenTelemetry counter for the number of executions of the observed code block."""
+        return self._executions
+
+    @property
+    def completions(self):
+        """Get the OpenTelemetry counter for the number of completions of the observed code block."""
+        return self._completions
+
+    @property
+    def exceptions(self):
+        """Get the OpenTelemetry counter for the number of exceptions caught in the observed code block."""
+        return self._exceptions
+
+    @property
+    def duration(self):
+        """Get the OpenTelemetry gauge for the duration of the observed code block."""
+        return self._duration
+
+
+class ExecutionResultObserver(ABC):
+    @abstractmethod
+    def evaluate_result(self, *args, **kwargs):
+        raise NotImplementedError("Subclasses must implement this method")
+
+
+class _NoopExecutionResultObserver(ExecutionResultObserver):
+    """A no-op observer that does not record any metrics."""
+
+    def evaluate_result(self, *args, **kwargs):
+        pass
+
+
+class _DagsterExecutionResultObserver(ExecutionResultObserver):
+    def __init__(
+        self,
+        instruments: ExecutionObserverInstruments,
+        attributes: dict[str, str],
+        result_evaluator_callback: Optional[ResultEvaluatorCallback] = None,
+    ):
+        self._result_evaluator_callback = result_evaluator_callback
+        self._instruments = instruments
+        self._attributes = attributes or {}
+        self._status = None
+
+    @property
+    def meter(self):
+        """Get the OpenTelemetry meter. This is useful for adding custom metrics."""
+        return self._instruments.meter
+
+    def evaluate_result(self, *args, **kwargs):
+        """Evaluate the result of the observed code block.
+
+        If a result evaluator callback is present, it will be called with the arguments passed to
+        this method, as well as the attributes and instruments passed to the observer.
+
+        If no result evaluator callback is present, the status will be set to "success".
+        """
+        if self._result_evaluator_callback:
+            self._status = self._result_evaluator_callback(
+                *args, attributes=self._attributes, instruments=self._instruments, **kwargs
+            )
+        else:
+            self._status = "success"
+
+    def set_status(self, status: str):
+        self._status = status
+
+    def get_status(self) -> Optional[str]:
+        return self._status
+
+
+@contextmanager
+def observe_execution(
+    opentelemetry: Optional[OpenTelemetryController],
+    event_key: str,
+    short_description: str,
+    result_evaluator_callback: Optional[ResultEvaluatorCallback] = None,
+    attributes: Optional[dict[str, str]] = None,
+):
+    """This context manager is used to observe the execution of a code block.
+
+    It records the number of executions, completions, exceptions, and the duration of the code block.
+    An optional evaluator callback can be provided to evaluate the result of the code block,
+    setting a completion status and also optionally implementing other side effects such as
+    recording additional metrics or logging based on the results.
+    """
+    attributes = attributes or {}
+    if opentelemetry and opentelemetry.metrics_enabled:
+        instruments = ExecutionObserverInstruments(
+            opentelemetry=opentelemetry,
+            metric_base_name=event_key,
+            description=short_description,
+        )
+        instruments.executions.add(1, attributes)
+
+        start_time = get_current_timestamp()
+        observer = _DagsterExecutionResultObserver(
+            instruments=instruments,
+            attributes=attributes,
+            result_evaluator_callback=result_evaluator_callback,
+        )
+
+        try:
+            yield observer
+        except DagsterError as e:
+            err_attributes = extract_dagster_error_attributes(e)
+            observer.set_status("exception")
+            instruments.exceptions.add(1, attributes={**attributes, **err_attributes})
+            raise
+        except Exception as e:
+            err_attributes = {"exception": type(e).__name__, **attributes}
+            observer.set_status("exception")
+            instruments.exceptions.add(1, err_attributes)
+            raise
+        finally:
+            instruments.completions.add(
+                1, attributes={**attributes, "status": observer.get_status() or "unknown"}
+            )
+            instruments.duration.record(get_current_timestamp() - start_time, attributes)
+
+    else:
+        yield _NoopExecutionResultObserver()

dagster_cloud/pex/grpc/__generated__/multi_pex_api_pb2.pyi

@@ -0,0 +1,175 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+If you make changes to this file, run "python -m dagster_cloud.pex.grpc.compile" after."""
+import builtins
+import google.protobuf.descriptor
+import google.protobuf.message
+import sys
+
+if sys.version_info >= (3, 8):
+    import typing as typing_extensions
+else:
+    import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing_extensions.final
+class Empty(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    def __init__(
+        self,
+    ) -> None: ...
+
+global___Empty = Empty
+
+@typing_extensions.final
+class CreatePexServerRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    CREATE_PEX_SERVER_ARGS_FIELD_NUMBER: builtins.int
+    create_pex_server_args: builtins.str
+    def __init__(
+        self,
+        *,
+        create_pex_server_args: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["create_pex_server_args", b"create_pex_server_args"]) -> None: ...
+
+global___CreatePexServerRequest = CreatePexServerRequest
+
+@typing_extensions.final
+class CreatePexServerReply(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    CREATE_PEX_SERVER_RESPONSE_FIELD_NUMBER: builtins.int
+    create_pex_server_response: builtins.str
+    def __init__(
+        self,
+        *,
+        create_pex_server_response: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["create_pex_server_response", b"create_pex_server_response"]) -> None: ...
+
+global___CreatePexServerReply = CreatePexServerReply
+
+@typing_extensions.final
+class GetPexServersRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    GET_PEX_SERVERS_ARGS_FIELD_NUMBER: builtins.int
+    get_pex_servers_args: builtins.str
+    def __init__(
+        self,
+        *,
+        get_pex_servers_args: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["get_pex_servers_args", b"get_pex_servers_args"]) -> None: ...
+
+global___GetPexServersRequest = GetPexServersRequest
+
+@typing_extensions.final
+class GetPexServersReply(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    GET_PEX_SERVERS_RESPONSE_FIELD_NUMBER: builtins.int
+    get_pex_servers_response: builtins.str
+    def __init__(
+        self,
+        *,
+        get_pex_servers_response: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["get_pex_servers_response", b"get_pex_servers_response"]) -> None: ...
+
+global___GetPexServersReply = GetPexServersReply
+
+@typing_extensions.final
+class GetCrashedPexServersRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    GET_CRASHED_PEX_SERVERS_ARGS_FIELD_NUMBER: builtins.int
+    get_crashed_pex_servers_args: builtins.str
+    def __init__(
+        self,
+        *,
+        get_crashed_pex_servers_args: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["get_crashed_pex_servers_args", b"get_crashed_pex_servers_args"]) -> None: ...
+
+global___GetCrashedPexServersRequest = GetCrashedPexServersRequest
+
+@typing_extensions.final
+class GetCrashedPexServersReply(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    GET_CRASHED_PEX_SERVERS_RESPONSE_FIELD_NUMBER: builtins.int
+    get_crashed_pex_servers_response: builtins.str
+    def __init__(
+        self,
+        *,
+        get_crashed_pex_servers_response: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["get_crashed_pex_servers_response", b"get_crashed_pex_servers_response"]) -> None: ...
+
+global___GetCrashedPexServersReply = GetCrashedPexServersReply
+
+@typing_extensions.final
+class ShutdownPexServerRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    SHUTDOWN_PEX_SERVER_ARGS_FIELD_NUMBER: builtins.int
+    shutdown_pex_server_args: builtins.str
+    def __init__(
+        self,
+        *,
+        shutdown_pex_server_args: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["shutdown_pex_server_args", b"shutdown_pex_server_args"]) -> None: ...
+
+global___ShutdownPexServerRequest = ShutdownPexServerRequest
+
+@typing_extensions.final
+class ShutdownPexServerReply(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    SHUTDOWN_PEX_SERVER_RESPONSE_FIELD_NUMBER: builtins.int
+    shutdown_pex_server_response: builtins.str
+    def __init__(
+        self,
+        *,
+        shutdown_pex_server_response: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["shutdown_pex_server_response", b"shutdown_pex_server_response"]) -> None: ...
+
+global___ShutdownPexServerReply = ShutdownPexServerReply
+
+@typing_extensions.final
+class PingRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    ECHO_FIELD_NUMBER: builtins.int
+    echo: builtins.str
+    def __init__(
+        self,
+        *,
+        echo: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["echo", b"echo"]) -> None: ...
+
+global___PingRequest = PingRequest
+
+@typing_extensions.final
+class PingReply(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    ECHO_FIELD_NUMBER: builtins.int
+    echo: builtins.str
+    def __init__(
+        self,
+        *,
+        echo: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["echo", b"echo"]) -> None: ...
+
+global___PingReply = PingReply

dagster_cloud/pex/grpc/__init__.py

@@ -1,8 +1,8 @@
-from .client import (
+from dagster_cloud.pex.grpc.client import (
     MultiPexGrpcClient as MultiPexGrpcClient,
     wait_for_grpc_server as wait_for_grpc_server,
 )
-from .types import (
+from dagster_cloud.pex.grpc.types import (
     CreatePexServerArgs as CreatePexServerArgs,
     GetPexServersArgs as GetPexServersArgs,
     PexServerHandle as PexServerHandle,

dagster_cloud/pex/grpc/client.py

@@ -9,11 +9,11 @@ from dagster._core.errors import DagsterUserCodeProcessError, DagsterUserCodeUnr
 from dagster._grpc.client import DEFAULT_GRPC_TIMEOUT
 from dagster._grpc.utils import max_rx_bytes, max_send_bytes
 from dagster._serdes import serialize_value
-from dagster._serdes.serdes import deserialize_value
 from dagster._utils.error import SerializableErrorInfo, serializable_error_info_from_exc_info
+from dagster_shared.serdes.serdes import deserialize_value
 
-from .__generated__ import MultiPexApiStub, multi_pex_api_pb2
-from .types import (
+from dagster_cloud.pex.grpc.__generated__ import MultiPexApiStub, multi_pex_api_pb2
+from dagster_cloud.pex.grpc.types import (
     CreatePexServerArgs,
     CreatePexServerResponse,
     GetCrashedPexServersArgs,
@@ -33,7 +33,7 @@ class MultiPexGrpcClient:
         if port:
             self._server_address = host + ":" + str(port)
         else:
-            self._server_address = "unix:" + os.path.abspath(socket)
+            self._server_address = "unix:" + os.path.abspath(socket)  # pyright: ignore[reportArgumentType,reportCallIssue]
 
     def create_pex_server(self, create_pex_server_args: CreatePexServerArgs):
         check.inst_param(create_pex_server_args, "create_pex_server_args", CreatePexServerArgs)