Merge branch 'dev' into andystaples/add-unit-testing-change

Author: andystaples

CODEOWNERS

@@ -9,7 +9,4 @@
 # For all file changes, github would automatically include the following people in the PRs.
 #
 
-* @nytian
-* @bachuv
-* @andystaples
-* @cgillum
+* @nytian @cgillum @bachuv @andystaples

CONTRIBUTING.md

@@ -123,16 +123,30 @@ pip install -e $REPOSITORY_ROOT/
 ```
 where REPOSITORY_ROOT is the root folder of the azure-functions-durable-python repository 
 
-7. Set breakpoints and click Run -> Start Debugging in VS Code. This should internally start the Azure Function using `func host start` command.
+7. Set breakpoints and click Run -> Start Debugging in VS Code. This should internally start the Azure Function using `func host start` command. If the breakpoints are not getting hit, check to make sure that you have set `justMyCode: false` in the function app's .vscode/launch.json.
+
+```
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      ...
+      "justMyCode": false
+      ...
+    }
+  ]
+}
+```
 
 ### Debugging end-to-end
 
 If you want to debug into the Durable Task or any of the .NET bits, follow instructions below:
 
-1. Open the Azure Storage Explorer and connect to the local storage emulator or the storage account you are using.
-2. Make sure the Durable Python debugging is setup already and the debugger has started the `func` process.
-3. In the VSCode editor for DurableTask, click Debug -> .NET Core Attach Process and search for `func host start` process and attach to it.
-4. Add a breakpoint in both editors and continue debugging.
+1. If you would like to debug a custom local WebJobs extension package then create the custom package, place it in a local directory, and then run `func extensions install --package Microsoft.Azure.WebJobs.Extensions.DurableTask --version <VERSION>`. If you update the version while debugging and the new version doesn't get picked up, then try running `func extensions install` to get the new changes.
+2. Open the Azure Storage Explorer and connect to the local storage emulator or the storage account you are using.
+3. Make sure the Durable Python debugging is setup already and the debugger has started the `func` process.
+4. In the VSCode editor for DurableTask, click Debug -> .NET Core Attach Process, search for `func host start` process and attach to it. If you are using Visual Studio, click Debug -> Attach to Process, search for the `func` process and attach to it.
+5. Add a breakpoint in both editors and continue debugging.
 
 ## Testing changes locally (Windows)
 

azure/durable_functions/models/DurableOrchestrationClient.py

@@ -4,6 +4,7 @@
 from time import time
 from asyncio import sleep
 from urllib.parse import urlparse, quote
+from opentelemetry import trace
 
 import azure.functions as func
 
@@ -71,8 +72,25 @@ async def start_new(self,
         request_url = self._get_start_new_url(
             instance_id=instance_id, orchestration_function_name=orchestration_function_name)
 
+        # Get the current span
+        current_span = trace.get_current_span()
+        span_context = current_span.get_span_context()
+
+        # Get the traceparent and tracestate from the span context
+        # Follows the W3C Trace Context specification for traceparent
+        # https://www.w3.org/TR/trace-context/#traceparent-header
+        trace_id = format(span_context.trace_id, '032x')
+        span_id = format(span_context.span_id, '016x')
+        trace_flags = format(span_context.trace_flags, '02x')
+        trace_parent = f"00-{trace_id}-{span_id}-{trace_flags}"
+
+        trace_state = span_context.trace_state
+
         response: List[Any] = await self._post_async_request(
-            request_url, self._get_json_input(client_input))
+            request_url,
+            self._get_json_input(client_input),
+            trace_parent,
+            trace_state)
 
         status_code: int = response[0]
         if status_code <= 202 and response[1]:

azure/durable_functions/models/utils/http_utils.py

@@ -3,7 +3,10 @@
 import aiohttp
 
 
-async def post_async_request(url: str, data: Any = None) -> List[Union[int, Any]]:
+async def post_async_request(url: str,
+                             data: Any = None,
+                             trace_parent: str = None,
+                             trace_state: str = None) -> List[Union[int, Any]]:
     """Post request with the data provided to the url provided.
 
     Parameters
@@ -12,15 +15,23 @@ async def post_async_request(url: str, data: Any = None) -> List[Union[int, Any]
         url to make the post to
     data: Any
         object to post
+    trace_parent: str
+        traceparent header to send with the request
+    trace_state: str
+        tracestate header to send with the request
 
     Returns
     -------
     [int, Any]
         Tuple with the Response status code and the data returned from the request
     """
     async with aiohttp.ClientSession() as session:
-        async with session.post(url,
-                                json=data) as response:
+        headers = {}
+        if trace_parent:
+            headers["traceparent"] = trace_parent
+        if trace_state:
+            headers["tracestate"] = trace_state
+        async with session.post(url, json=data, headers=headers) as response:
             # We disable aiohttp's input type validation
             # as the server may respond with alternative
             # data encodings. This is potentially unsafe.

requirements.txt

@@ -11,3 +11,5 @@ furl==2.1.0
 pytest-asyncio==0.20.2
 autopep8
 types-python-dateutil
+opentelemetry-api==1.32.1
+opentelemetry-sdk==1.32.1

tests/models/test_DurableOrchestrationClient.py

@@ -67,7 +67,7 @@ async def delete(self, url: str):
         assert url == self._expected_url
         return self._response
 
-    async def post(self, url: str, data: Any = None):
+    async def post(self, url: str, data: Any = None, trace_parent: str = None, trace_state: str = None):
         assert url == self._expected_url
         return self._response