@@ -9,11 +9,15 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ADDED
 
+- Added a `logger` parameter to `TaskHubGrpcClient`,
+`AsyncTaskHubGrpcClient`, and `TaskHubGrpcWorker`. Applications can now
+provide fully configured loggers without the SDK modifying their handlers,
+formatter, level, filters, or propagation.
 - Added `ExceptionPropertiesProvider` and the
 `exception_properties_provider` worker option to attach portable custom
-properties to activity, entity, and orchestration failures. Failure
-properties and recursive inner failures are available through
-`FailureDetails`, task-failure exceptions, orchestration state, and history.
+properties to activity, entity, and orchestration failures. Failure properties
+and recursive inner failures are available through `FailureDetails`,
+task-failure exceptions, orchestration state, and history.
 - Added an optional timeout to filtered orchestration purges. Callers can now
 limit a purge operation's duration and inspect `PurgeInstancesResult.is_complete`
 for completed, partial, or backend-unknown completion status.
@@ -23,8 +27,15 @@ instances whose IDs begin with a specified prefix.
 `AsyncTaskHubGrpcClient` suspend and resume operations. The reason is now sent
 to the backend with the lifecycle request.
 - Added the optional `new_version` argument to
-`OrchestrationContext.continue_as_new()` so continued orchestrations can
-switch to a new version.
+`OrchestrationContext.continue_as_new()` so continued orchestrations can switch
+to a new version.
+
+CHANGED
+
+- Deprecated the `log_handler` and `log_formatter` parameters on
+`TaskHubGrpcClient`, `AsyncTaskHubGrpcClient`, and `TaskHubGrpcWorker`.
+Configure and pass a `logger` instead. These parameters will be removed in a
+future major release.
 
 ## v1.9.0
 
 
@@ -24,6 +24,13 @@ FIXED
 discarding their `reason` arguments. Reasons are now forwarded to the Durable
 Task backend.
 
+CHANGED
+
+- Durable Functions client and worker logs now use the Azure Functions
+host-managed `azure.durable_functions` logger hierarchy instead of private SDK
+handlers. Configure their level, destination, and telemetry routing through the
+standard Functions/Python logging configuration.
+
 ## v2.0.0b2
 
 ADDED
 
@@ -4,6 +4,7 @@
 import asyncio
 import atexit
 import json
+import logging
 import threading
 
 from datetime import datetime, timedelta
@@ -35,6 +36,7 @@
 
 _sync_client_cache: dict[str, "SyncDurableFunctionsClient"] = {}
 _sync_client_cache_lock = threading.Lock()
+_LOGGER = logging.getLogger(__name__)
 
 
 def _first_forwarded_value(value: str) -> str:
@@ -176,7 +178,8 @@ def __init__(self, client_as_string: str):
             interceptors=interceptors,
             channel_options=channel_options,
             data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER,
-            emit_trace_spans=False)
+            emit_trace_spans=False,
+            logger=_LOGGER)
 
         # The gRPC aio channel is bound to the event loop it is created on. A
         # ``durable_client_input`` decode runs on the worker's invocation loop,
@@ -661,7 +664,8 @@ def __init__(self, client_as_string: str):
             interceptors=interceptors,
             channel_options=channel_options,
             data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER,
-            emit_trace_spans=False)
+            emit_trace_spans=False,
+            logger=_LOGGER)
 
     @classmethod
     def get_cached(cls, client_as_string: str) -> "SyncDurableFunctionsClient":
 
@@ -2,6 +2,7 @@
 # Licensed under the MIT License.
 
 import base64
+import logging
 from threading import Lock
 from typing import Any, Optional
 
@@ -19,6 +20,8 @@
 from .internal.compat.orchestration_context import wrap_orchestrator
 from .internal.serialization import DEFAULT_FUNCTIONS_DATA_CONVERTER
 
+_LOGGER = logging.getLogger(__name__)
+
 
 # Host-driven Azure Functions execution engine for orchestrator and entity
 # functions. Despite subclassing ``TaskHubGrpcWorker``, it never opens a gRPC
@@ -44,6 +47,7 @@ def __init__(self) -> None:
         super().__init__(
             data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER,
             emit_trace_spans=False,
+            logger=_LOGGER,
         )
         self._registration_lock = Lock()
         self._registered_orchestrator_functions: dict[
 
@@ -268,6 +268,77 @@ message formatting.
 > Create the replay-safe logger once at the start of your orchestrator
 > and reuse it throughout the function.
 
+### SDK logging
+
+`TaskHubGrpcClient`, `AsyncTaskHubGrpcClient`, and `TaskHubGrpcWorker`
+accept a configured `logging.Logger` through their `logger` parameter. The
+SDK uses a supplied logger unchanged: it does not add handlers or modify its
+formatter, level, filters, or propagation setting. The Durable Task Scheduler
+client and worker accept the same parameter.
+
+Use one shared logger when client and worker records should use the same
+destination, format, and correlation filters:
+
+```python
+import logging
+
+from durabletask.client import TaskHubGrpcClient
+from durabletask.worker import TaskHubGrpcWorker
+
+sdk_logger = logging.getLogger("myapp.durabletask")
+sdk_logger.setLevel(logging.INFO)
+
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter(
+    "%(asctime)s %(name)s %(levelname)s %(message)s"))
+sdk_logger.addHandler(handler)
+sdk_logger.propagate = False
+
+worker = TaskHubGrpcWorker(logger=sdk_logger)
+client = TaskHubGrpcClient(logger=sdk_logger)
+```
+
+Because `logging.getLogger()` returns the same logger for a given name,
+configure a shared logger once during application startup. Do not add a new
+handler every time a client or worker is constructed, or every record will be
+emitted once by each handler.
+
+Alternatively, configure handlers on the root logger and allow propagation:
+
+```python
+import logging
+
+logging.basicConfig(level=logging.INFO)
+sdk_logger = logging.getLogger("myapp.durabletask")
+
+worker = TaskHubGrpcWorker(logger=sdk_logger)
+client = TaskHubGrpcClient(logger=sdk_logger)
+```
+
+> [!WARNING]
+> Use either handlers attached directly to `sdk_logger` with
+> `sdk_logger.propagate = False`, or root handlers with propagation enabled.
+> Combining both emits each Durable Task record twice.
+
+Pass separate named loggers when clients and workers need independently
+configured levels, destinations, or filters:
+
+```python
+worker = TaskHubGrpcWorker(
+    logger=logging.getLogger("myapp.durabletask.worker"))
+client = TaskHubGrpcClient(
+    logger=logging.getLogger("myapp.durabletask.client"))
+```
+
+The older `log_handler` and `log_formatter` parameters are deprecated. They
+will be removed in a future major release. Passing either one together with
+`logger` raises `ValueError`; none of the supplied logging options are ignored.
+
+> [!NOTE]
+> SDK clients and workers emit detailed `DEBUG` logs that can help diagnose
+> orchestration behavior. Enable that level on the logger you pass to the SDK
+> when reproducing an issue.
+
 ### Large payload externalization
 
 Orchestration inputs, outputs, and event data are transmitted through gRPC messages. When these
@@ -571,34 +642,6 @@ export_client = ExportHistoryClient(
 > first-party destinations (S3, GCS, etc.) will be packaged as
 > additional optional extras using the same pattern.
 
-### Logging configuration
-
-Both the TaskHubGrpcWorker and TaskHubGrpcClient (as well as DurableTaskSchedulerWorker and
-DurableTaskSchedulerClient for durabletask-azuremanaged) accept a log_handler and log_formatter
-object from `logging`. These can be used to customize verbosity, output location, and format of logs
-emitted by these sources.
-
-For example, to output logs to a file called `worker.log` at level `DEBUG`, the following syntax
-might apply:
-
-```python
-log_handler = logging.FileHandler('durable.log', encoding='utf-8')
-log_handler.setLevel(logging.DEBUG)
-
-with DurableTaskSchedulerWorker(
-    host_address=endpoint,
-    secure_channel=secure_channel,
-    taskhub=taskhub_name,
-    token_credential=credential,
-    log_handler=log_handler,
-) as w:
-```
-
-> [!NOTE]
-> The worker and client output many logs at the `DEBUG` level that will be useful when understanding
-orchestration flow and diagnosing issues with Durable applications. Before submitting issues, please
-attempt a repro of the issue with debug logging enabled.
-
 ### Work item filtering
 
 By default a worker receives **all** work items from the backend, regardless of which
 
@@ -9,6 +9,10 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ADDED
 
+- Added a `logger` parameter to `DurableTaskSchedulerClient`,
+`AsyncDurableTaskSchedulerClient`, and `DurableTaskSchedulerWorker`.
+Applications can now provide fully configured loggers without the SDK modifying
+them.
 - Added `exception_properties_provider` to `DurableTaskSchedulerWorker` for
 attaching portable custom properties to activity, entity, and orchestration
 failures.
@@ -19,6 +23,13 @@ orchestration instances whose IDs begin with a specified prefix.
 - Added optional `reason` parameters to suspend and resume operations inherited
 from `TaskHubGrpcClient` and `AsyncTaskHubGrpcClient`.
 
+CHANGED
+
+- Deprecated the `log_handler` and `log_formatter` parameters on
+`DurableTaskSchedulerClient`, `AsyncDurableTaskSchedulerClient`, and
+`DurableTaskSchedulerWorker`. Configure and pass a `logger` instead. These
+parameters will be removed in a future major release.
+
 ## v1.9.0
 
 CHANGED
 
@@ -38,7 +38,8 @@ def __init__(self, *,
                  payload_store: PayloadStore | None = None,
                  data_converter: DataConverter | None = None,
                  log_handler: logging.Handler | None = None,
-                 log_formatter: logging.Formatter | None = None):
+                 log_formatter: logging.Formatter | None = None,
+                 logger: logging.Logger | None = None):
 
         if not taskhub:
             raise ValueError("Taskhub value cannot be empty. Please provide a value for your taskhub")
@@ -57,6 +58,7 @@ def __init__(self, *,
             metadata=None,
             log_handler=log_handler,
             log_formatter=log_formatter,
+            logger=logger,
             interceptors=resolved_interceptors,
             channel_options=channel_options,
             resiliency_options=resiliency_options,
@@ -86,8 +88,13 @@ class AsyncDurableTaskSchedulerClient(AsyncTaskHubGrpcClient):
         default_version (str | None, optional): Default version string for orchestrations.
         payload_store (PayloadStore | None, optional): A payload store for
             externalizing large payloads. If None, payloads are sent inline.
-        log_handler (logging.Handler | None, optional): Custom logging handler for client logs.
-        log_formatter (logging.Formatter | None, optional): Custom log formatter for client logs.
+        log_handler (logging.Handler | None, optional): Deprecated custom logging
+            handler for client logs. Use ``logger`` instead.
+        log_formatter (logging.Formatter | None, optional): Deprecated custom log
+            formatter. Use ``logger`` instead.
+        logger (logging.Logger | None, optional): Caller-configured logger for
+            client logs. It cannot be combined with ``log_handler`` or
+            ``log_formatter``; doing so raises ``ValueError``.
 
     Raises:
         ValueError: If taskhub is empty or None.
@@ -118,7 +125,8 @@ def __init__(self, *,
                  payload_store: PayloadStore | None = None,
                  data_converter: DataConverter | None = None,
                  log_handler: logging.Handler | None = None,
-                 log_formatter: logging.Formatter | None = None):
+                 log_formatter: logging.Formatter | None = None,
+                 logger: logging.Logger | None = None):
 
         if not taskhub:
             raise ValueError("Taskhub value cannot be empty. Please provide a value for your taskhub")
@@ -137,6 +145,7 @@ def __init__(self, *,
             metadata=None,
             log_handler=log_handler,
             log_formatter=log_formatter,
+            logger=logger,
             interceptors=resolved_interceptors,
             channel_options=channel_options,
             resiliency_options=resiliency_options,
 
@@ -48,8 +48,13 @@ class DurableTaskSchedulerWorker(TaskHubGrpcWorker):
             settings will be used.
         payload_store (PayloadStore | None, optional): A payload store for
             externalizing large payloads. If None, payloads are sent inline.
-        log_handler (logging.Handler | None, optional): Custom logging handler for worker logs.
-        log_formatter (logging.Formatter | None, optional): Custom log formatter for worker logs.
+        log_handler (logging.Handler | None, optional): Deprecated custom logging
+            handler for worker logs. Use ``logger`` instead.
+        log_formatter (logging.Formatter | None, optional): Deprecated custom log
+            formatter. Use ``logger`` instead.
+        logger (logging.Logger | None, optional): Caller-configured logger for
+            worker logs. It cannot be combined with ``log_handler`` or
+            ``log_formatter``; doing so raises ``ValueError``.
         exception_properties_provider (ExceptionPropertiesProvider | None, optional):
             Extracts portable custom properties from exceptions reported by this worker.
 
@@ -91,6 +96,7 @@ def __init__(self, *,
                  data_converter: DataConverter | None = None,
                  log_handler: logging.Handler | None = None,
                  log_formatter: logging.Formatter | None = None,
+                 logger: logging.Logger | None = None,
                  exception_properties_provider: ExceptionPropertiesProvider | None = None):
 
         if not taskhub:
@@ -113,6 +119,7 @@ def __init__(self, *,
             metadata=None,
             log_handler=log_handler,
             log_formatter=log_formatter,
+            logger=logger,
             interceptors=resolved_interceptors,
             channel_options=channel_options,
             resiliency_options=resiliency_options,
 
@@ -423,6 +423,7 @@ def __init__(self, *,
                  metadata: list[tuple[str, str]] | None = None,
                  log_handler: logging.Handler | None = None,
                  log_formatter: logging.Formatter | None = None,
+                 logger: logging.Logger | None = None,
                  channel: grpc.Channel | None = None,
                  secure_channel: bool = False,
                  interceptors: Sequence[shared.ClientInterceptor] | None = None,
@@ -433,6 +434,7 @@ def __init__(self, *,
                  data_converter: DataConverter | None = None,
                  emit_trace_spans: bool = True):
 
+        self._logger = shared.get_logger("client", log_handler, log_formatter, logger)
         self._owns_channel = channel is None
         self._data_converter = data_converter if data_converter is not None else JsonDataConverter()
         self._host_address = (
@@ -493,7 +495,6 @@ def __init__(self, *,
         # can prepend the interceptor themselves via grpc.intercept_channel.
         self._channel = channel
         self._stub = cast(_SyncTaskHubSidecarServiceStub, stubs.TaskHubSidecarServiceStub(channel))
-        self._logger = shared.get_logger("client", log_handler, log_formatter)
         self.default_version = default_version
         self._payload_store = payload_store
         self._emit_trace_spans = emit_trace_spans
@@ -962,6 +963,7 @@ def __init__(self, *,
                  metadata: list[tuple[str, str]] | None = None,
                  log_handler: logging.Handler | None = None,
                  log_formatter: logging.Formatter | None = None,
+                 logger: logging.Logger | None = None,
                  channel: grpc.aio.Channel | None = None,
                  secure_channel: bool = False,
                  interceptors: Sequence[shared.AsyncClientInterceptor] | None = None,
@@ -972,6 +974,7 @@ def __init__(self, *,
                  data_converter: DataConverter | None = None,
                  emit_trace_spans: bool = True):
 
+        self._logger = shared.get_logger("async_client", log_handler, log_formatter, logger)
         self._owns_channel = channel is None
         self._data_converter = data_converter if data_converter is not None else JsonDataConverter()
         self._host_address = (
@@ -1029,7 +1032,6 @@ def __init__(self, *,
             if channel is not None
             else None
         )
-        self._logger = shared.get_logger("async_client", log_handler, log_formatter)
         self.default_version = default_version
         self._payload_store = payload_store
         self._emit_trace_spans = emit_trace_spans