@uknows/setup 0.1.0 → 0.2.0

package/lib/git.mjs

@@ -45,3 +45,56 @@ function onlyIgnored(root, dir, ignore, budget = { left: 2000 }) {
   }
   return true
 }
+
+/**
+ * True when git ignores this path: .gitignore files, .git/info/exclude or the global excludes. Then git add -A leaves
+ * the file out of the commit. False when git does not ignore it, or cannot tell (no git, not a repo).
+ * @param {string} root  absolute path of the folder setup works in
+ * @param {string} path  relative to root, '/' separated
+ */
+export function gitIgnored(root, path) {
+  const r = spawnSync('git', ['-C', root, 'check-ignore', '-q', '--', path], { encoding: 'utf8' })
+  return !r.error && r.status === 0
+}
+
+/**
+ * The GitHub repo of the origin remote, as owner/name, for the gh commands of the key steps. null when there is no
+ * git, no origin, or the origin is not on github.com. Reads the git config only.
+ * @param {string} root  absolute path of the folder setup works in
+ * @returns {string|null}
+ */
+export function gitRemote(root) {
+  const r = spawnSync('git', ['-C', root, 'config', '--get', 'remote.origin.url'], { encoding: 'utf8' })
+  if (r.error || r.status !== 0) return null
+  return githubSlug(r.stdout.trim())
+}
+
+/**
+ * Where the origin remote is hosted: 'github', 'gitlab', 'azure-devops', 'bitbucket' or 'other'. null when there is no
+ * git or no origin. Reads the git config only. The update bot that setup adds depends on it (updates.mjs).
+ * @param {string} root  absolute path of the folder setup works in
+ * @returns {'github'|'gitlab'|'azure-devops'|'bitbucket'|'other'|null}
+ */
+export function gitHost(root) {
+  const r = spawnSync('git', ['-C', root, 'config', '--get', 'remote.origin.url'], { encoding: 'utf8' })
+  if (r.error || r.status !== 0 || !r.stdout.trim()) return null
+  return hostOfRemote(r.stdout.trim())
+}
+
+/** The host of a remote address, by its host name: GitHub (also GitHub Enterprise), GitLab, Azure DevOps, Bitbucket. */
+export function hostOfRemote(url) {
+  const m = /^(?:[a-z+]+:\/\/)?(?:[^@/]+@)?([^/:]+)/i.exec(String(url ?? '').trim())
+  const host = (m?.[1] ?? '').toLowerCase()
+  if (!host) return 'other'
+  if (/(^|\.)github\.com$|github/.test(host)) return 'github'
+  if (/gitlab/.test(host)) return 'gitlab'
+  if (/(^|\.)dev\.azure\.com$|\.visualstudio\.com$|^ssh\.dev\.azure\.com$/.test(host)) return 'azure-devops'
+  if (/bitbucket/.test(host)) return 'bitbucket'
+  return 'other'
+}
+
+/** owner/name from a GitHub remote: https://github.com/o/n(.git), git@github.com:o/n(.git) or ssh://git@github.com/o/n. */
+export function githubSlug(url) {
+  const m = /^(?:https?:\/\/(?:[^@/]+@)?|ssh:\/\/git@|git@)github\.com[/:]([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/.exec(url ?? '')
+  return m ? `${m[1]}/${m[2]}` : null
+}

package/lib/hooks/UknowsOpenTelemetry.cs

@@ -0,0 +1,118 @@
+// Added by npx @uknows/setup. UKNOWS for Azure Functions (.NET isolated worker), for a function app that keeps
+// Application Insights. A server span for each call of a function, as a child of the trace that the Functions host passes
+// on (so UKNOWS and Application Insights share the trace id), and the logs of the function with that span, over OTLP.
+// The settings are the OTEL_* app settings of the function app. Not Microsoft.Azure.Functions.Worker.OpenTelemetry:
+// with it, the logs of the functions stopped reaching Application Insights (measured 22 Oct 2026). Program.cs calls
+// UseMiddleware<UknowsOpenTelemetry>() and UknowsOpenTelemetry.AddTo(services). To undo it, run npx @uknows/setup remove.
+// Tested with Microsoft.Azure.Functions.Worker 2.52 on .NET 10 (Functions host 4.1055).
+using System.Diagnostics;
+using System.Reflection;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.Azure.Functions.Worker.Middleware;
+using Microsoft.Extensions.DependencyInjection;
+using OpenTelemetry;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
+
+namespace Uknows.AzureFunctions;
+
+public sealed class UknowsOpenTelemetry : IFunctionsWorkerMiddleware
+{
+    public const string SourceName = "Uknows.AzureFunctions";
+    private static readonly ActivitySource Source = new(SourceName);
+
+    /// <summary>The host in Application Insights mode passes a trace context that is not sampled: follow its trace id, but record.</summary>
+    private static readonly Sampler Sampler = new ParentBasedSampler(new AlwaysOnSampler(),
+        remoteParentSampled: new AlwaysOnSampler(), remoteParentNotSampled: new AlwaysOnSampler(),
+        localParentSampled: new AlwaysOnSampler(), localParentNotSampled: new AlwaysOnSampler());
+
+    /// <summary>The OpenTelemetry SDK: the spans of this middleware and the logs, over OTLP.</summary>
+    public static void AddTo(IServiceCollection services)
+    {
+        var otel = services.AddOpenTelemetry()
+            .ConfigureResource(r => r.AddAttributes(Azure()).AddEnvironmentVariableDetector())
+            .WithTracing(tracing => tracing.AddSource(SourceName).SetSampler(Sampler));
+        if (Environment.GetEnvironmentVariable("OTEL_LOGS_EXPORTER") != "none") otel.WithLogging();
+        otel.UseOtlpExporter();
+    }
+
+    /// <summary>The function app in Azure, from the variables that App Service sets.</summary>
+    private static IEnumerable<KeyValuePair<string, object>> Azure()
+    {
+        var env = (string name) => Environment.GetEnvironmentVariable(name);
+        var sub = (env("WEBSITE_OWNER_NAME") ?? "").Split('+')[0];
+        var (group, site, region) = (env("WEBSITE_RESOURCE_GROUP"), env("WEBSITE_SITE_NAME"), env("REGION_NAME"));
+        yield return new("cloud.provider", "azure");
+        yield return new("cloud.platform", "azure_functions");
+        if (!string.IsNullOrEmpty(region)) yield return new("cloud.region", region);
+        if (sub.Length > 0 && !string.IsNullOrEmpty(group) && !string.IsNullOrEmpty(site))
+            yield return new("cloud.resource_id", $"/subscriptions/{sub}/resourceGroups/{group}/providers/Microsoft.Web/sites/{site}");
+    }
+
+    public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
+    {
+        ActivityContext.TryParse(context.TraceContext?.TraceParent, context.TraceContext?.TraceState, isRemote: true, out var parent);
+        var http = context.FunctionDefinition.InputBindings.Values.Any(b => b.Type.Equals("httpTrigger", StringComparison.OrdinalIgnoreCase));
+        var request = http ? await context.GetHttpRequestDataAsync() : null;
+        var route = http ? $"/api/{RouteOf(context.FunctionDefinition) ?? context.FunctionDefinition.Name}" : null;
+        using var activity = Source.StartActivity(http ? $"{request?.Method} {route}" : context.FunctionDefinition.Name,
+            http ? ActivityKind.Server : ActivityKind.Internal, parent);
+        activity?.SetTag("faas.name", context.FunctionDefinition.Name);
+        activity?.SetTag("faas.invocation_id", context.InvocationId);
+        activity?.SetTag("faas.trigger", http ? "http" : "other");
+        if (http)
+        {
+            activity?.SetTag("http.request.method", request?.Method);
+            activity?.SetTag("http.route", route);
+        }
+        try
+        {
+            await next(context);
+            var status = http ? (int?)context.GetHttpResponseData()?.StatusCode : null;
+            if (status is not null)
+            {
+                activity?.SetTag("http.response.status_code", status);
+                if (status >= 500) activity?.SetStatus(ActivityStatusCode.Error);
+            }
+        }
+        catch (Exception ex)
+        {
+            // The type of the exception and the file and line of each frame, never the message.
+            activity?.SetStatus(ActivityStatusCode.Error);
+            if (http) activity?.SetTag("http.response.status_code", 500);
+            activity?.AddEvent(new ActivityEvent("exception", tags: new ActivityTagsCollection
+            {
+                { "exception.type", ex.GetType().FullName },
+                { "exception.stacktrace", Frames(ex) },
+            }));
+            throw;
+        }
+    }
+
+    /// <summary>The frames of the exception: method, file and line, as .NET prints them, without the message.</summary>
+    private static string Frames(Exception ex) => string.Join("\n", (new StackTrace(ex, fNeedFileInfo: true).GetFrames() ?? [])
+        .Select(f => $"   at {f.GetMethod()?.DeclaringType?.FullName}.{f.GetMethod()?.Name}" +
+            (f.GetFileName() is { } file ? $" in {file}:line {f.GetFileLineNumber()}" : "")));
+
+    private static readonly Dictionary<string, string?> Routes = new();
+
+    /// <summary>The Route of the HttpTrigger attribute of the function's method.</summary>
+    private static string? RouteOf(FunctionDefinition f)
+    {
+        lock (Routes)
+        {
+            if (Routes.TryGetValue(f.Id, out var known)) return known;
+            string? route = null;
+            var dot = f.EntryPoint.LastIndexOf('.');
+            var type = dot > 0 ? Type.GetType($"{f.EntryPoint[..dot]}, {Path.GetFileNameWithoutExtension(f.PathToAssembly)}") : null;
+            var method = type?.GetMethods().FirstOrDefault(m => m.Name == f.EntryPoint[(dot + 1)..]);
+            foreach (var p in method?.GetParameters() ?? [])
+            {
+                var attribute = p.GetCustomAttributes().FirstOrDefault(a => a.GetType().Name == "HttpTriggerAttribute");
+                if (attribute is not null) route = attribute.GetType().GetProperty("Route")?.GetValue(attribute) as string;
+            }
+            return Routes[f.Id] = route;
+        }
+    }
+}

package/lib/hooks/pins.mjs

@@ -0,0 +1,28 @@
+// The UKNOWS hooks for Azure Functions (stacks/functions-hooks.mjs): what each language adds, at the versions measured
+// on the bench. A module of its own with no imports, so the manifest check can read the package names too.
+/** What each language adds, at the versions measured on the bench, and the versions that the bench ran. */
+export const HOOKS = {
+  node: {
+    file: 'uknows-otel.cjs',
+    packages: [['@opentelemetry/api', '1.9.1'], ['@opentelemetry/api-logs', '0.223.0'], ['@opentelemetry/exporter-logs-otlp-http', '0.223.0'],
+      ['@opentelemetry/exporter-trace-otlp-http', '0.223.0'], ['@opentelemetry/resources', '2.12.0'], ['@opentelemetry/sdk-logs', '0.223.0'],
+      ['@opentelemetry/sdk-trace-node', '2.12.0']],
+    tested: [['@azure/functions', '4.16']],
+  },
+  python: {
+    file: 'uknows_otel.py',
+    packages: [['opentelemetry-api', '1.45.1'], ['opentelemetry-sdk', '1.45.1'], ['opentelemetry-exporter-otlp-proto-http', '1.45.1']],
+    settings: [{ name: 'PYTHON_ENABLE_WORKER_EXTENSIONS', value: '1' }],
+    tested: [['azure-functions', '1.25']],
+  },
+  dotnet: {
+    file: 'UknowsOpenTelemetry.cs',
+    packages: [['OpenTelemetry.Extensions.Hosting', '1.19.1'], ['OpenTelemetry.Exporter.OpenTelemetryProtocol', '1.19.1']],
+    tested: [['Microsoft.Azure.Functions.Worker', '2.52']],
+  },
+}
+/** The host version and runtimes of the bench (shown with the tested versions). */
+export const TESTED_ON = 'Functions host 4.1055, Node.js 22, Python 3.12, .NET 10, Linux'
+/** The files of the hooks, by name: a pull request that has one of them adds the hooks. */
+export const HOOK_FILES = Object.values(HOOKS).map((h) => h.file)
+

package/lib/hooks/uknows-otel.cjs

@@ -0,0 +1,82 @@
+// Added by npx @uknows/setup. UKNOWS for Azure Functions (Node.js), for a function app that keeps Application Insights.
+// A server span for each call of a function, as a child of the trace that the Functions host passes on (so UKNOWS and
+// Application Insights share the trace id), and the logs of the function with that span, over OTLP. The settings are
+// the OTEL_* app settings of the function app. This file does not tell the host that the worker sends logs, so the host
+// keeps sending them to Application Insights exactly as before. To undo it, run npx @uknows/setup remove.
+// Tested with @azure/functions 4.16 on Node.js 22 (Functions host 4.1055).
+const { app } = require('@azure/functions')
+const { SpanKind, SpanStatusCode, context, propagation, trace } = require('@opentelemetry/api')
+const { SeverityNumber } = require('@opentelemetry/api-logs')
+const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-http')
+const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http')
+const { defaultResource, detectResources, envDetector, resourceFromAttributes } = require('@opentelemetry/resources')
+const { BatchLogRecordProcessor, LoggerProvider } = require('@opentelemetry/sdk-logs')
+const { AlwaysOnSampler, BatchSpanProcessor, NodeTracerProvider, ParentBasedSampler } = require('@opentelemetry/sdk-trace-node')
+
+/** The function app in Azure, from the variables that App Service sets. */
+function azure() {
+  const env = process.env
+  const sub = (env.WEBSITE_OWNER_NAME ?? '').split('+')[0]
+  const group = env.WEBSITE_RESOURCE_GROUP, site = env.WEBSITE_SITE_NAME
+  return { 'cloud.provider': 'azure', 'cloud.platform': 'azure_functions', ...(env.REGION_NAME ? { 'cloud.region': env.REGION_NAME } : {}),
+    ...(sub && group && site ? { 'cloud.resource_id': `/subscriptions/${sub}/resourceGroups/${group}/providers/Microsoft.Web/sites/${site}` } : {}) }
+}
+
+const resource = defaultResource().merge(resourceFromAttributes(azure())).merge(detectResources({ detectors: [envDetector] }))
+// The host in Application Insights mode passes a trace context that is not sampled: follow its trace id, but record.
+const sampler = new ParentBasedSampler({ root: new AlwaysOnSampler(), remoteParentNotSampled: new AlwaysOnSampler() })
+const tracerProvider = new NodeTracerProvider({ resource, sampler, spanProcessors: [new BatchSpanProcessor(new OTLPTraceExporter())] })
+tracerProvider.register()
+const tracer = tracerProvider.getTracer('uknows-azure-functions')
+const logs = (process.env.OTEL_LOGS_EXPORTER ?? 'otlp') !== 'none'
+const logger = logs ? new LoggerProvider({ resource, processors: [new BatchLogRecordProcessor({ exporter: new OTLPLogExporter() })] }).getLogger('uknows-azure-functions') : null
+const SEVERITY = { trace: SeverityNumber.TRACE, debug: SeverityNumber.DEBUG, information: SeverityNumber.INFO, warning: SeverityNumber.WARN,
+  error: SeverityNumber.ERROR, critical: SeverityNumber.FATAL }
+/** The span of each call that runs, by invocation id. */
+const spans = new Map()
+
+app.hook.preInvocation((ctx) => {
+  const inv = ctx.invocationContext
+  const tc = inv.traceContext
+  const parent = tc?.traceParent ? propagation.extract(context.active(), { traceparent: tc.traceParent, tracestate: tc.traceState }) : context.active()
+  const trigger = inv.options?.trigger
+  const http = trigger?.type === 'httpTrigger'
+  const req = http ? ctx.inputs[0] : null
+  const route = http ? `/api/${trigger.route ?? inv.functionName}` : null
+  const span = tracer.startSpan(http ? `${req.method} ${route}` : inv.functionName, {
+    kind: http ? SpanKind.SERVER : SpanKind.INTERNAL,
+    attributes: { 'faas.name': inv.functionName, 'faas.invocation_id': inv.invocationId, 'faas.trigger': http ? 'http' : 'other',
+      ...(http ? { 'http.request.method': req.method, 'http.route': route } : {}) },
+  }, parent)
+  spans.set(inv.invocationId, span)
+  ctx.functionHandler = context.bind(trace.setSpan(parent, span), ctx.functionHandler)
+})
+
+app.hook.postInvocation((ctx) => {
+  const id = ctx.invocationContext.invocationId
+  const span = spans.get(id)
+  if (!span) return
+  spans.delete(id)
+  const status = ctx.error ? 500 : Number(ctx.result?.status ?? 200)
+  if (ctx.invocationContext.options?.trigger?.type === 'httpTrigger') span.setAttribute('http.response.status_code', status)
+  // The type of the error and the file and line of each frame, never the message.
+  if (ctx.error) span.addEvent('exception', { 'exception.type': typeName(ctx.error), 'exception.stacktrace': frames(ctx.error) })
+  if (ctx.error || status >= 500) span.setStatus({ code: SpanStatusCode.ERROR })
+  span.end()
+})
+
+/** The class name of an error, or the type of a thrown value that is not an Error. */
+function typeName(error) {
+  return error instanceof Error ? (error.constructor?.name || error.name || 'Error') : typeof error
+}
+/** The frames of a stack ("    at fn (file:line:column)"), without its first line, which holds the message. */
+function frames(error) {
+  return String(error?.stack ?? '').split('\n').filter((line) => /^\s+at /.test(line)).join('\n')
+}
+
+app.hook.log((ctx) => {
+  if (!logger || ctx.category !== 'user') return
+  const span = spans.get(ctx.invocationContext?.invocationId)
+  logger.emit({ body: ctx.message, severityNumber: SEVERITY[ctx.level] ?? SeverityNumber.INFO, severityText: ctx.level,
+    context: span ? trace.setSpan(context.active(), span) : context.active() })
+})

package/lib/hooks/uknows_otel.py

@@ -0,0 +1,179 @@
+"""Added by npx @uknows/setup. UKNOWS for Azure Functions (Python), for a function app that keeps Application Insights.
+
+A server span for each call of a function, as a child of the trace that the Functions host passes on (so UKNOWS and
+Application Insights share the trace id), and the logs of the function with that span, over OTLP. The settings are the
+OTEL_* app settings of the function app, and PYTHON_ENABLE_WORKER_EXTENSIONS=1. To undo it, run npx @uknows/setup remove.
+
+A worker extension of azure-functions (AppExtensionBase): the worker runs its hooks before and after each call, in the
+thread (or task) of the call. It does not set PYTHON_ENABLE_OPENTELEMETRY, so the host keeps sending the logs to
+Application Insights exactly as before. The worker skips the after-hook when the function raises, so instrument(app)
+also wraps each function: a call that raises ends its span with status error and an exception event. The event has the
+exception type and the file, line and function of each frame, never the message, the source lines or local values.
+Tested with azure-functions 1.25 on Python 3.12 (Functions host 4.1055).
+"""
+import contextvars
+import functools
+import inspect
+import logging
+import os
+import traceback
+
+import azure.functions as func
+from opentelemetry import _logs, context, trace
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.sampling import ALWAYS_ON, ParentBased
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+
+def _azure():
+    """The function app in Azure, from the variables that App Service sets."""
+    env = os.environ
+    sub = env.get("WEBSITE_OWNER_NAME", "").split("+")[0]
+    group, site = env.get("WEBSITE_RESOURCE_GROUP"), env.get("WEBSITE_SITE_NAME")
+    out = {"cloud.provider": "azure", "cloud.platform": "azure_functions"}
+    if env.get("REGION_NAME"):
+        out["cloud.region"] = env["REGION_NAME"]
+    if sub and group and site:
+        out["cloud.resource_id"] = f"/subscriptions/{sub}/resourceGroups/{group}/providers/Microsoft.Web/sites/{site}"
+    return out
+
+
+# OTEL_RESOURCE_ATTRIBUTES and OTEL_SERVICE_NAME win over the Azure attributes.
+_resource = Resource.create(_azure()).merge(Resource.create())
+# The host of a function app in App Insights mode passes a trace context that is not sampled, so a span of UKNOWS
+# follows that trace id but is always recorded.
+_tracer_provider = TracerProvider(resource=_resource, sampler=ParentBased(root=ALWAYS_ON, remote_parent_not_sampled=ALWAYS_ON))
+_tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
+trace.set_tracer_provider(_tracer_provider)
+if os.environ.get("OTEL_LOGS_EXPORTER", "otlp") != "none":
+    _logger_provider = LoggerProvider(resource=_resource)
+    _logger_provider.add_log_record_processor(BatchLogRecordProcessor(OTLPLogExporter()))
+    _logs.set_logger_provider(_logger_provider)
+    # The logs of the app: the root logger, at INFO (the host's default), not the worker's own logs.
+    _handler = LoggingHandler(level=logging.INFO, logger_provider=_logger_provider)
+    _handler.addFilter(lambda record: not record.name.startswith("azure_functions_worker"))
+    logging.getLogger().addHandler(_handler)
+
+_tracer = trace.get_tracer("uknows-azure-functions")
+_propagator = TraceContextTextMapPropagator()
+# The span of the call that runs, and its context token: a context variable, so async calls on one thread stay apart.
+_current = contextvars.ContextVar("uknows_span", default=None)
+
+
+class UknowsOpenTelemetry(func.AppExtensionBase):
+    """Opens a span before each call and closes it after."""
+
+    @classmethod
+    def init(cls):
+        pass
+
+    @classmethod
+    def configure(cls, *args, **kwargs):
+        pass
+
+    @classmethod
+    def pre_invocation_app_level(cls, logger, context_, func_args, *args, **kwargs):
+        tc = getattr(context_, "trace_context", None)
+        parent = _propagator.extract({"traceparent": tc.trace_parent, "tracestate": tc.trace_state}) if tc and tc.trace_parent else None
+        req = next((a for a in (func_args or {}).values() if isinstance(a, func.HttpRequest)), None)
+        if req is not None:
+            name = f"{req.method} {_route_of(context_.function_name)}"
+            attributes = {"http.request.method": req.method, "http.route": _route_of(context_.function_name)}
+            kind = SpanKind.SERVER
+        else:
+            name, attributes, kind = context_.function_name, {}, SpanKind.INTERNAL
+        attributes.update({"faas.name": context_.function_name, "faas.invocation_id": context_.invocation_id,
+                           "faas.trigger": "http" if req is not None else "other"})
+        span = _tracer.start_span(name, context=parent, kind=kind, attributes=attributes)
+        token = context.attach(trace.set_span_in_context(span, parent))
+        _current.set((span, token, req is not None))
+
+    @classmethod
+    def post_invocation_app_level(cls, logger, context_, func_args, func_ret, *args, **kwargs):
+        status = getattr(func_ret, "status_code", None)
+        _end(int(status) if status is not None else None)
+
+
+def _end(status=None, error=None):
+    """Ends the span of the call that runs: with its status code, or as failed with the exception event."""
+    current = _current.get()
+    if current is None:
+        return
+    span, token, http = current
+    _current.set(None)
+    if error is not None:
+        span.add_event("exception", {"exception.type": _type_name(error), "exception.stacktrace": _frames(error)})
+        span.set_status(Status(StatusCode.ERROR))
+        status = 500 if http else None
+    if status is not None:
+        span.set_attribute("http.response.status_code", status)
+        if status >= 500:
+            span.set_status(Status(StatusCode.ERROR))
+    span.end()
+    context.detach(token)
+
+
+def _type_name(error):
+    t = type(error)
+    return t.__qualname__ if t.__module__ == "builtins" else f"{t.__module__}.{t.__qualname__}"
+
+
+def _frames(error):
+    """The file, line and function of each frame, as a traceback prints them, without the source lines."""
+    frames = [f for f in traceback.extract_tb(error.__traceback__) if f.filename != __file__]
+    return "\n".join(f'  File "{f.filename}", line {f.lineno}, in {f.name}' for f in frames)
+
+
+def _wrap(fn):
+    """The function, with its span ended when it raises (the worker then skips the after-hook)."""
+    if inspect.iscoroutinefunction(fn):
+        @functools.wraps(fn)
+        async def run(*args, **kwargs):
+            try:
+                return await fn(*args, **kwargs)
+            except BaseException as error:
+                _end(error=error)
+                raise
+    else:
+        @functools.wraps(fn)
+        def run(*args, **kwargs):
+            try:
+                return fn(*args, **kwargs)
+            except BaseException as error:
+                _end(error=error)
+                raise
+    return run
+
+
+_APPS = []
+_ROUTES = {}
+
+
+def _route_of(function_name):
+    """/api/<route> of the function, read from the app on first use (app.get_functions() may run only once: the worker
+    calls it, and a second call fails its check of unique names)."""
+    if function_name not in _ROUTES:
+        for app in _APPS:
+            for fb in getattr(app, "_function_builders", []):
+                f = getattr(fb, "_function", None)
+                route = getattr(f.get_trigger(), "route", None) if f is not None and f.get_trigger() is not None else None
+                if f is not None and route is not None:
+                    _ROUTES[f.get_function_name()] = f"/api/{route}"
+    return _ROUTES.get(function_name, f"/api/{function_name}")
+
+
+def instrument(app):
+    """Call at the end of function_app.py: the routes name the spans, and each function ends its span when it raises."""
+    _APPS.append(app)
+    for fb in getattr(app, "_function_builders", []):
+        f = getattr(fb, "_function", None)
+        if f is not None and callable(getattr(f, "_func", None)) and not getattr(f._func, "_uknows", False):
+            f._func = _wrap(f._func)
+            f._func._uknows = True
+