fix(azure_functions): instrument azure functions regardless of decorator order (#13592)

Refactor Azure Functions instrumentation to patch the
`FunctionApp.get_functions` method instead of the individual decorators
for each trigger.

## Additional Notes

When the `function_name` decorator is first the function Datadog
instrumentation succeeds.
```
@app.function_name(name="customname")
@app.route(route="httpexample", auth_level=func.AuthLevel.ANONYMOUS)
def http_example(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello Datadog!")
```

However if the `function_name` decorator is second, which is valid for
an uninstrumented function, Datadog instrumentation fails with the error
below.
```
@app.route(route="httpexample", auth_level=func.AuthLevel.ANONYMOUS)
@app.function_name(name="customname")
def http_example(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello Datadog!")
```

```
[2025-06-04T15:47:21.117Z] Worker failed to index functions
[2025-06-04T15:47:21.118Z] Result: Failure
[2025-06-04T15:47:21.118Z] Exception: AttributeError: 'FunctionBuilder' object has no attribute '__name__'
```

This error happens because the decorators are patched one at a time in
order, and if the `function_name` decorator is patched after the `route`
decorator, then the patch method for `route` is missing information it
expected from the `function_name` decorator.

By patching
[get_functions](https://github.com/Azure/azure-functions-python-library/blob/03dc59a10d6116e36c5255d3d3649db2d525a472/azure/functions/decorators/function_app.py#L3902)
instead, we can access all functions right before they are loaded by the
[Python Azure Functions
Worker](https://github.com/Azure/azure-functions-python-worker/blob/9b17af96794307f4d34fc3ce8a6193aab9d7299f/azure_functions_worker/loader.py#L264)
and wrap the user defined methods to create spans.

## Checklist
- [x] PR author has checked that all the criteria below are met
- The PR description includes an overview of the change
- The PR description articulates the motivation for the change
- The change includes tests OR the PR description describes a testing
strategy
- The PR description notes risks associated with the change, if any
- Newly-added code is easy to change
- The change follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/releasenotes.html)
- The change includes or references documentation updates if necessary
- Backport labels are set (if
[applicable](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting))

## Reviewer Checklist
- [x] Reviewer has checked that all the criteria below are met 
- Title is accurate
- All changes are related to the pull request's stated goal
- Avoids breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes
- Testing strategy adequately addresses listed risks
- Newly-added code is easy to change
- Release note makes sense to a user of the library
- If necessary, author has acknowledged and discussed the performance
implications of this PR as reported in the benchmarks PR comment
- Backport labels are set in a manner that is consistent with the
[release branch maintenance
policy](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting)

Author: duncanpharvey

ddtrace/contrib/internal/azure_functions/patch.py

@@ -11,7 +11,6 @@
 from ddtrace.trace import Pin
 
 from .utils import create_context
-from .utils import get_function_name
 from .utils import wrap_function_with_tracing
 
 
@@ -39,109 +38,92 @@ def patch():
     azure_functions._datadog_patch = True
 
     Pin().onto(azure_functions.FunctionApp)
-    _w("azure.functions", "FunctionApp.function_name", _patched_function_name)
-    _w("azure.functions", "FunctionApp.route", _patched_route)
-    _w("azure.functions", "FunctionApp.service_bus_queue_trigger", _patched_service_bus_trigger)
-    _w("azure.functions", "FunctionApp.service_bus_topic_trigger", _patched_service_bus_trigger)
-    _w("azure.functions", "FunctionApp.timer_trigger", _patched_timer_trigger)
+    _w("azure.functions", "FunctionApp.get_functions", _patched_get_functions)
 
 
-def _patched_function_name(wrapped, instance, args, kwargs):
-    Pin.override(instance, tags={"function_name": kwargs.get("name")})
-    return wrapped(*args, **kwargs)
-
-
-def _patched_route(wrapped, instance, args, kwargs):
-    trigger = "Http"
-    trigger_arg_name = kwargs.get("trigger_arg_name", "req")
-
+def _patched_get_functions(wrapped, instance, args, kwargs):
     pin = Pin.get_from(instance)
     if not pin or not pin.enabled():
         return wrapped(*args, **kwargs)
 
-    def _wrapper(func):
-        function_name = get_function_name(pin, instance, func)
-
-        def context_factory(kwargs):
-            req = kwargs.get(trigger_arg_name)
-            return create_context("azure.functions.patched_route_request", pin, headers=req.headers)
+    functions = wrapped(*args, **kwargs)
 
-        def pre_dispatch(ctx, kwargs):
-            req = kwargs.get(trigger_arg_name)
-            ctx.set_item("req_span", ctx.span)
-            return ("azure.functions.request_call_modifier", (ctx, config.azure_functions, req))
+    for function in functions:
+        trigger = function.get_trigger()
+        if not trigger:
+            continue
 
-        def post_dispatch(ctx, res):
-            return ("azure.functions.start_response", (ctx, config.azure_functions, res, function_name, trigger))
+        trigger_type = trigger.get_binding_name()
+        trigger_arg_name = trigger.name
 
-        wrap_function = wrap_function_with_tracing(
-            func, context_factory, pre_dispatch=pre_dispatch, post_dispatch=post_dispatch
-        )
+        function_name = function.get_function_name()
+        func = function.get_user_function()
 
-        return wrapped(*args, **kwargs)(wrap_function)
+        if trigger_type == "httpTrigger":
+            function._func = _wrap_http_trigger(pin, func, function_name, trigger_arg_name)
+        elif trigger_type == "timerTrigger":
+            function._func = _wrap_timer_trigger(pin, func, function_name)
+        elif trigger_type == "serviceBusTrigger":
+            function._func = _wrap_service_bus_trigger(pin, func, function_name)
 
-    return _wrapper
+    return functions
 
 
-def _patched_service_bus_trigger(wrapped, instance, args, kwargs):
-    trigger = "ServiceBus"
+def _wrap_http_trigger(pin, func, function_name, trigger_arg_name):
+    trigger_type = "Http"
 
-    pin = Pin.get_from(instance)
-    if not pin or not pin.enabled():
-        return wrapped(*args, **kwargs)
+    def context_factory(kwargs):
+        req = kwargs.get(trigger_arg_name)
+        return create_context("azure.functions.patched_route_request", pin, headers=req.headers)
 
-    def _wrapper(func):
-        function_name = get_function_name(pin, instance, func)
+    def pre_dispatch(ctx, kwargs):
+        req = kwargs.get(trigger_arg_name)
+        ctx.set_item("req_span", ctx.span)
+        return ("azure.functions.request_call_modifier", (ctx, config.azure_functions, req))
 
-        def context_factory(kwargs):
-            resource_name = f"{trigger} {function_name}"
-            return create_context("azure.functions.patched_service_bus", pin, resource_name)
+    def post_dispatch(ctx, res):
+        return ("azure.functions.start_response", (ctx, config.azure_functions, res, function_name, trigger_type))
 
-        def pre_dispatch(ctx, kwargs):
-            ctx.set_item("trigger_span", ctx.span)
-            return (
-                "azure.functions.trigger_call_modifier",
-                (ctx, config.azure_functions, function_name, trigger, SpanKind.CONSUMER),
-            )
+    return wrap_function_with_tracing(func, context_factory, pre_dispatch=pre_dispatch, post_dispatch=post_dispatch)
 
-        wrap_function = wrap_function_with_tracing(func, context_factory, pre_dispatch=pre_dispatch)
 
-        return wrapped(*args, **kwargs)(wrap_function)
+def _wrap_service_bus_trigger(pin, func, function_name):
+    trigger_type = "ServiceBus"
 
-    return _wrapper
+    def context_factory(kwargs):
+        resource_name = f"{trigger_type} {function_name}"
+        return create_context("azure.functions.patched_service_bus", pin, resource_name)
 
+    def pre_dispatch(ctx, kwargs):
+        ctx.set_item("trigger_span", ctx.span)
+        return (
+            "azure.functions.trigger_call_modifier",
+            (ctx, config.azure_functions, function_name, trigger_type, SpanKind.CONSUMER),
+        )
 
-def _patched_timer_trigger(wrapped, instance, args, kwargs):
-    trigger = "Timer"
-
-    pin = Pin.get_from(instance)
-    if not pin or not pin.enabled():
-        return wrapped(*args, **kwargs)
-
-    def _wrapper(func):
-        function_name = get_function_name(pin, instance, func)
+    return wrap_function_with_tracing(func, context_factory, pre_dispatch=pre_dispatch)
 
-        def context_factory(kwargs):
-            resource_name = f"{trigger} {function_name}"
-            return create_context("azure.functions.patched_timer", pin, resource_name)
 
-        def pre_dispatch(ctx, kwargs):
-            ctx.set_item("trigger_span", ctx.span)
-            return (
-                "azure.functions.trigger_call_modifier",
-                (ctx, config.azure_functions, function_name, trigger, SpanKind.INTERNAL),
-            )
+def _wrap_timer_trigger(pin, func, function_name):
+    trigger_type = "Timer"
 
-        wrap_function = wrap_function_with_tracing(func, context_factory, pre_dispatch=pre_dispatch)
+    def context_factory(kwargs):
+        resource_name = f"{trigger_type} {function_name}"
+        return create_context("azure.functions.patched_timer", pin, resource_name)
 
-        return wrapped(*args, **kwargs)(wrap_function)
+    def pre_dispatch(ctx, kwargs):
+        ctx.set_item("trigger_span", ctx.span)
+        return (
+            "azure.functions.trigger_call_modifier",
+            (ctx, config.azure_functions, function_name, trigger_type, SpanKind.INTERNAL),
+        )
 
-    return _wrapper
+    return wrap_function_with_tracing(func, context_factory, pre_dispatch=pre_dispatch)
 
 
 def unpatch():
     if not getattr(azure_functions, "_datadog_patch", False):
         return
     azure_functions._datadog_patch = False
 
-    _u(azure_functions.FunctionApp, "route")
+    _u(azure_functions.FunctionApp, "get_functions")

ddtrace/contrib/internal/azure_functions/utils.py

@@ -6,7 +6,6 @@
 from ddtrace.ext import SpanTypes
 from ddtrace.internal import core
 from ddtrace.internal.schema import schematize_cloud_faas_operation
-from ddtrace.trace import Pin
 
 
 def create_context(context_name, pin, resource=None, headers=None):
@@ -26,15 +25,6 @@ def create_context(context_name, pin, resource=None, headers=None):
     )
 
 
-def get_function_name(pin, instance, func):
-    if pin.tags and pin.tags.get("function_name"):
-        function_name = pin.tags.get("function_name")
-        Pin.override(instance, tags={"function_name": ""})
-    else:
-        function_name = func.__name__
-    return function_name
-
-
 def wrap_function_with_tracing(func, context_factory, pre_dispatch=None, post_dispatch=None):
     if inspect.iscoroutinefunction(func):
 

releasenotes/notes/fix-azure-functions-decorator-order-ef1920cf7379530d.yaml

@@ -0,0 +1,3 @@
+fixes:
+  - |
+    azure_functions: This fix resolves an issue where functions throw an error on loading when the function_name decorator follows another decorator.

tests/contrib/azure_functions/azure_function_app/function_app.py

@@ -53,6 +53,14 @@ def http_get_function_name_no_decorator(req: func.HttpRequest) -> func.HttpRespo
     return func.HttpResponse("Hello Datadog!")
 
 
+@app.route(
+    route="httpgetfunctionnamedecoratororder", auth_level=func.AuthLevel.ANONYMOUS, methods=[func.HttpMethod.GET]
+)
+@app.function_name(name="functionnamedecoratororder")
+def http_get_function_name_decorator_order(req: func.HttpRequest) -> func.HttpResponse:
+    return func.HttpResponse("Hello Datadog!")
+
+
 @app.route(route="httpgetroot", auth_level=func.AuthLevel.ANONYMOUS, methods=[func.HttpMethod.GET])
 def http_get_root(req: func.HttpRequest) -> func.HttpResponse:
     requests.get(f"http://localhost:{os.environ['AZURE_FUNCTIONS_TEST_PORT']}/api/httpgetchild", timeout=5)

tests/contrib/azure_functions/test_azure_functions_snapshot.py

@@ -107,6 +107,13 @@ def test_http_get_function_name_no_decorator(azure_functions_client: Client) ->
     assert azure_functions_client.get("/api/httpgetfunctionnamenodecorator", headers=DEFAULT_HEADERS).status_code == 200
 
 
+@pytest.mark.snapshot
+def test_http_get_function_name_decorator_order(azure_functions_client: Client) -> None:
+    assert (
+        azure_functions_client.get("/api/httpgetfunctionnamedecoratororder", headers=DEFAULT_HEADERS).status_code == 200
+    )
+
+
 @pytest.mark.parametrize(
     "azure_functions_client",
     [{}, DISTRIBUTED_TRACING_DISABLED_PARAMS],

tests/snapshots/tests.contrib.azure_functions.test_azure_functions_snapshot.test_http_get_function_name_decorator_order.json

@@ -0,0 +1,33 @@
+[[
+  {
+    "name": "azure.functions.invoke",
+    "service": "test-func",
+    "resource": "GET /api/httpgetfunctionnamedecoratororder",
+    "trace_id": 0,
+    "span_id": 1,
+    "parent_id": 0,
+    "type": "serverless",
+    "meta": {
+      "_dd.p.dm": "-0",
+      "_dd.p.tid": "684055f800000000",
+      "aas.function.name": "functionnamedecoratororder",
+      "aas.function.trigger": "Http",
+      "component": "azure_functions",
+      "http.method": "GET",
+      "http.route": "/api/httpgetfunctionnamedecoratororder",
+      "http.status_code": "200",
+      "http.url": "http://0.0.0.0:7071/api/httpgetfunctionnamedecoratororder",
+      "http.useragent": "python-httpx/x.xx.x",
+      "language": "python",
+      "runtime-id": "e0b373739eb742d29f13fdb6cb71a98e",
+      "span.kind": "server"
+    },
+    "metrics": {
+      "_dd.top_level": 1,
+      "_dd.tracer_kr": 1.0,
+      "_sampling_priority_v1": 1,
+      "process_id": 53880
+    },
+    "duration": 278416,
+    "start": 1749046776355682801
+  }]]