From 2e804df251a2a6993ea09cb2801c80cff40fe154 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Mon, 20 Oct 2025 20:36:07 -0400
Subject: [PATCH 01/48] [Instrumentation.Hangfire] Add metrics support

Implements OpenTelemetry workflow semantic conventions for Hangfire metrics.

Fixes #2075
---
 .../.publicApi/PublicAPI.Unshipped.txt        |   6 +
 .../HangfireInstrumentationOptions.cs         |  10 +
 .../Implementation/HangfireMetrics.cs         |  72 ++++
 .../HangfireMetricsErrorFilterAttribute.cs    |  30 ++
 .../HangfireMetricsInstrumentation.cs         |  42 ++
 .../HangfireMetricsJobFilterAttribute.cs      |  36 ++
 .../HangfireMetricsStateFilter.cs             | 107 +++++
 .../HangfireQueueLatencyFilterAttribute.cs    |  71 ++++
 .../Implementation/HangfireTagBuilder.cs      | 201 +++++++++
 .../MeterProviderBuilderExtensions.cs         |  66 +++
 ...nTelemetry.Instrumentation.Hangfire.csproj |   1 -
 .../README.md                                 | 193 ++++++++-
 .../CustomTestException.cs                    |  14 +
 .../HangfireFixture.cs                        |  43 ++
 ...eInstrumentationJobFilterAttributeTests.cs |  42 +-
 .../HangfireMetricsErrorTests.cs              | 208 ++++++++++
 .../HangfireMetricsTests.cs                   | 387 ++++++++++++++++++
 .../HangfireQueueLatencyTests.cs              | 225 ++++++++++
 .../MetricPointExtensions.cs                  |  84 ++++
 ...etry.Instrumentation.Hangfire.Tests.csproj |   2 -
 .../TestJobWithCustomException.cs             |  16 +
 .../Utils/AssertUtils.cs                      |  94 +++++
 .../Utils/MetricCollectionExtensions.cs       |  20 +
 23 files changed, 1931 insertions(+), 39 deletions(-)
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireQueueLatencyFilterAttribute.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/MetricPointExtensions.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/TestJobWithCustomException.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/AssertUtils.cs
 create mode 100644 test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt b/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
index 7c2225b43f..e1ffb99341 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
@@ -1,3 +1,4 @@
+OpenTelemetry.Metrics.MeterProviderBuilderExtensions
 OpenTelemetry.Trace.HangfireInstrumentationOptions
 OpenTelemetry.Trace.HangfireInstrumentationOptions.DisplayNameFunc.get -> System.Func<Hangfire.BackgroundJob!, string!>!
 OpenTelemetry.Trace.HangfireInstrumentationOptions.DisplayNameFunc.set -> void
@@ -6,7 +7,12 @@ OpenTelemetry.Trace.HangfireInstrumentationOptions.Filter.set -> void
 OpenTelemetry.Trace.HangfireInstrumentationOptions.HangfireInstrumentationOptions() -> void
 OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordException.get -> bool
 OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordException.set -> void
+OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordQueueLatency.get -> bool
+OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordQueueLatency.set -> void
 OpenTelemetry.Trace.TracerProviderBuilderExtensions
+static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder) -> OpenTelemetry.Metrics.MeterProviderBuilder!
+static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
+static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder) -> OpenTelemetry.Trace.TracerProviderBuilder!
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Trace.TracerProviderBuilder!
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Trace.TracerProviderBuilder!
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
index 467fe880b6..2a931b2804 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
@@ -45,4 +45,14 @@ public class HangfireInstrumentationOptions
     /// </list>
     /// </remarks>
     public Func<BackgroundJob, bool>? Filter { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to record queue latency metrics.
+    /// </summary>
+    /// <remarks>
+    /// When enabled, records the time jobs spend waiting in the queue before execution.
+    /// This requires an additional database call per job execution to retrieve the enqueue timestamp.
+    /// Default is <see langword="false"/> to avoid performance impact in high-throughput scenarios.
+    /// </remarks>
+    public bool RecordQueueLatency { get; set; }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
new file mode 100644
index 0000000000..c34afbb2b3
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
@@ -0,0 +1,72 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Diagnostics.Metrics;
+using System.Reflection;
+using OpenTelemetry.Internal;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Centralized metrics definitions for Hangfire instrumentation.
+/// </summary>
+internal static class HangfireMetrics
+{
+    private static readonly Assembly Assembly = typeof(HangfireMetrics).Assembly;
+    private static readonly AssemblyName AssemblyName = Assembly.GetName();
+    internal static readonly string MeterName = AssemblyName.Name!;
+    private static readonly string InstrumentationVersion = Assembly.GetPackageVersion();
+
+    // Metric name constants
+    internal const string ExecutionCountMetricName = "workflow.execution.count";
+    internal const string ExecutionDurationMetricName = "workflow.execution.duration";
+    internal const string ExecutionStatusMetricName = "workflow.execution.status";
+    internal const string ExecutionErrorsMetricName = "workflow.execution.errors";
+
+    internal const string QueueLatencyMetricName = "hangfire.queue.latency";
+
+    /// <summary>
+    /// The meter instance for all Hangfire metrics.
+    /// </summary>
+    public static readonly Meter Meter = new(MeterName, InstrumentationVersion);
+
+    /// <summary>
+    /// Counter for the number of task executions which have been initiated.
+    /// Follows OpenTelemetry workflow semantic conventions.
+    /// </summary>
+    public static readonly Counter<long> ExecutionCount =
+        Meter.CreateCounter<long>(ExecutionCountMetricName, unit: "{executions}",
+            description: "The number of task executions which have been initiated.");
+
+    /// <summary>
+    /// Histogram for duration of an execution grouped by task, type and result.
+    /// Follows OpenTelemetry workflow semantic conventions.
+    /// </summary>
+    public static readonly Histogram<double> ExecutionDuration =
+        Meter.CreateHistogram<double>(ExecutionDurationMetricName, unit: "s",
+            description: "Duration of an execution grouped by task, type and result.");
+
+    /// <summary>
+    /// UpDownCounter for the number of actively running tasks grouped by task and state.
+    /// Follows OpenTelemetry workflow semantic conventions.
+    /// </summary>
+    public static readonly UpDownCounter<long> ExecutionStatus =
+        Meter.CreateUpDownCounter<long>(ExecutionStatusMetricName, unit: "{executions}",
+            description: "The number of actively running tasks grouped by task, type and the current state.");
+
+    /// <summary>
+    /// Counter for the number of errors encountered in task runs (eg. compile, test failures).
+    /// Follows OpenTelemetry workflow semantic conventions.
+    /// </summary>
+    public static readonly Counter<long> ExecutionErrors =
+        Meter.CreateCounter<long>(ExecutionErrorsMetricName, unit: "{error}",
+            description: "The number of errors encountered in task runs (eg. compile, test failures).");
+
+    /// <summary>
+    /// Histogram for time tasks spend waiting in queue before execution.
+    /// Hangfire-specific metric (not part of standard workflow conventions).
+    /// </summary>
+    public static readonly Histogram<double> QueueLatency =
+        Meter.CreateHistogram<double>(QueueLatencyMetricName, unit: "s",
+            description: "Time tasks spend waiting in queue before execution starts.");
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
new file mode 100644
index 0000000000..24f76b25be
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
@@ -0,0 +1,30 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire.Common;
+using Hangfire.Server;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Hangfire filter that records OpenTelemetry error metrics for job execution failures.
+/// Follows OpenTelemetry workflow semantic conventions for workflow.execution.errors metric.
+/// </summary>
+internal sealed class HangfireMetricsErrorFilterAttribute : JobFilterAttribute, IServerFilter
+{
+    public void OnPerforming(PerformingContext performingContext)
+    {
+    }
+
+    public void OnPerformed(PerformedContext performedContext)
+    {
+        if (performedContext.Exception != null)
+        {
+            var errorTags = HangfireTagBuilder.BuildErrorTags(
+                performedContext.BackgroundJob.Job,
+                performedContext.Exception);
+
+            HangfireMetrics.ExecutionErrors.Add(1, errorTags);
+        }
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
new file mode 100644
index 0000000000..eba09572ee
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
@@ -0,0 +1,42 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Hangfire metrics instrumentation following OpenTelemetry workflow semantic conventions.
+/// </summary>
+internal sealed class HangfireMetricsInstrumentation : IDisposable
+{
+    private readonly List<object> filters = new();
+
+    public HangfireMetricsInstrumentation(HangfireInstrumentationOptions options)
+    {
+        this.AddFilter(new HangfireMetricsJobFilterAttribute());
+        this.AddFilter(new HangfireMetricsStateFilter());
+        this.AddFilter(new HangfireMetricsErrorFilterAttribute());
+
+        // Only register queue latency filter if enabled (requires DB call per job)
+        if (options.RecordQueueLatency)
+        {
+            this.AddFilter(new HangfireQueueLatencyFilterAttribute());
+        }
+    }
+
+    public void Dispose()
+    {
+        foreach (var filter in this.filters)
+        {
+            GlobalJobFilters.Filters.Remove(filter);
+        }
+    }
+
+    private void AddFilter(object filter)
+    {
+        this.filters.Add(filter);
+        GlobalJobFilters.Filters.Add(filter);
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
new file mode 100644
index 0000000000..821c71810e
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Diagnostics;
+using Hangfire.Common;
+using Hangfire.Server;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Hangfire filter that records OpenTelemetry metrics for job execution.
+/// </summary>
+internal sealed class HangfireMetricsJobFilterAttribute : JobFilterAttribute, IServerFilter
+{
+    private const string StopwatchKey = "OpenTelemetry.Metrics.Stopwatch";
+
+    public void OnPerforming(PerformingContext performingContext)
+    {
+        performingContext.Items[StopwatchKey] = Stopwatch.StartNew();
+    }
+
+    public void OnPerformed(PerformedContext performedContext)
+    {
+        var executionTags = HangfireTagBuilder.BuildExecutionTags(performedContext.BackgroundJob.Job, performedContext.Exception);
+
+        HangfireMetrics.ExecutionCount.Add(1, executionTags);
+
+        if (performedContext.Items.TryGetValue(StopwatchKey, out var stopwatchObj) && stopwatchObj is Stopwatch stopwatch)
+        {
+            stopwatch.Stop();
+            var duration = stopwatch.Elapsed.TotalSeconds;
+
+            HangfireMetrics.ExecutionDuration.Record(duration, executionTags);
+        }
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
new file mode 100644
index 0000000000..2576c7ee33
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -0,0 +1,107 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire.Common;
+using Hangfire.States;
+using Hangfire.Storage;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Hangfire state change filter responsible for emitting workflow execution status metrics.
+/// </summary>
+internal sealed class HangfireMetricsStateFilter : JobFilterAttribute, IApplyStateFilter
+{
+    public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
+    {
+        var workflowState = HangfireTagBuilder.MapWorkflowState(context.NewState.Name);
+        if (workflowState == null)
+        {
+            return;
+        }
+
+        var errorType = GetErrorTypeFromNewState(context.NewState);
+        var recurringJobId = GetRecurringJobId(context);
+        var tags = HangfireTagBuilder.BuildStateTags(
+            context.BackgroundJob.Job,
+            workflowState,
+            errorType,
+            recurringJobId);
+
+        HangfireMetrics.ExecutionStatus.Add(1, tags);
+    }
+
+    public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
+    {
+        var workflowState = HangfireTagBuilder.MapWorkflowState(context.OldStateName);
+        if (workflowState == null)
+        {
+            return;
+        }
+
+        var errorType = GetErrorTypeFromOldState(context);
+        var recurringJobId = GetRecurringJobId(context);
+        var tags = HangfireTagBuilder.BuildStateTags(
+            context.BackgroundJob.Job,
+            workflowState,
+            errorType,
+            recurringJobId);
+
+        HangfireMetrics.ExecutionStatus.Add(-1, tags);
+    }
+
+    private static string? GetErrorTypeFromNewState(IState state)
+    {
+        if (!string.Equals(state.Name, FailedState.StateName, StringComparison.Ordinal))
+        {
+            return null;
+        }
+
+        if (state is FailedState failedState && failedState.Exception != null)
+        {
+            var exceptionType = failedState.Exception.GetType();
+            return exceptionType.FullName ?? exceptionType.Name;
+        }
+
+        return TryGetExceptionTypeFromSerializedData(state.SerializeData());
+    }
+
+    private static string? GetErrorTypeFromOldState(ApplyStateContext context)
+    {
+        if (!string.Equals(context.OldStateName, FailedState.StateName, StringComparison.Ordinal))
+        {
+            return null;
+        }
+
+        StateData? stateData = context.Connection.GetStateData(context.BackgroundJob.Id);
+        return stateData != null ? TryGetExceptionTypeFromSerializedData(stateData.Data) : null;
+    }
+
+    private static string? TryGetExceptionTypeFromSerializedData(IDictionary<string, string>? data)
+    {
+        if (data == null)
+        {
+            return null;
+        }
+
+        if (data.TryGetValue("ExceptionType", out var exceptionType) && !string.IsNullOrWhiteSpace(exceptionType))
+        {
+            return exceptionType;
+        }
+
+        return null;
+    }
+
+    private static string? GetRecurringJobId(ApplyStateContext context)
+    {
+        try
+        {
+            return context.Connection.GetJobParameter(context.BackgroundJob.Id, "RecurringJobId");
+        }
+        catch
+        {
+            // Parameter doesn't exist or couldn't be retrieved
+            return null;
+        }
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireQueueLatencyFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireQueueLatencyFilterAttribute.cs
new file mode 100644
index 0000000000..1833de18ba
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireQueueLatencyFilterAttribute.cs
@@ -0,0 +1,71 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire.Common;
+using Hangfire.Server;
+using Hangfire.States;
+using DateTime = System.DateTime;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Hangfire filter that records queue latency metrics.
+/// </summary>
+/// <remarks>
+/// This filter captures the EnqueuedAt timestamp when a job enters the Enqueued state
+/// and calculates queue latency when the job starts executing.
+/// </remarks>
+internal sealed class HangfireQueueLatencyFilterAttribute : JobFilterAttribute, IServerFilter, IElectStateFilter
+{
+    private const string EnqueuedAtParameter = "OpenTelemetry.EnqueuedAt";
+
+    public void OnStateElection(ElectStateContext context)
+    {
+        // When a job transitions to Enqueued state, capture the EnqueuedAt timestamp
+        if (context.CandidateState is EnqueuedState enqueuedState)
+        {
+            try
+            {
+                var enqueuedAt = enqueuedState.EnqueuedAt;
+                context.Connection.SetJobParameter(
+                    context.BackgroundJob.Id,
+                    EnqueuedAtParameter,
+                    JobHelper.SerializeDateTime(enqueuedAt));
+            }
+            catch
+            {
+                // Skip storing timestamp if parameter write fails
+                // Instrumentation must never break Hangfire's scheduling pipeline
+            }
+        }
+    }
+
+    public void OnPerforming(PerformingContext performingContext)
+    {
+        try
+        {
+            // Retrieve the EnqueuedAt timestamp that was stored when the job was enqueued
+            var enqueuedAtStr = performingContext.Connection.GetJobParameter(
+                performingContext.BackgroundJob.Id,
+                EnqueuedAtParameter);
+
+            if (!string.IsNullOrEmpty(enqueuedAtStr))
+            {
+                var enqueuedAt = JobHelper.DeserializeDateTime(enqueuedAtStr);
+                var queueLatency = (DateTime.UtcNow - enqueuedAt).TotalSeconds;
+
+                var tags = HangfireTagBuilder.BuildCommonTags(performingContext.BackgroundJob.Job);
+                HangfireMetrics.QueueLatency.Record(queueLatency, tags);
+            }
+        }
+        catch
+        {
+            // Skip recording if parameter retrieval fails
+        }
+    }
+
+    public void OnPerformed(PerformedContext performedContext)
+    {
+        // No-op: This filter only handles queue latency in OnPerforming
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
new file mode 100644
index 0000000000..504020a3b8
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -0,0 +1,201 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Diagnostics;
+using Hangfire.Common;
+using Hangfire.Server;
+using Hangfire.States;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Tag builder for creating standardized OpenTelemetry tag lists for Hangfire job metrics.
+/// Follows OpenTelemetry workflow semantic conventions.
+/// </summary>
+internal static class HangfireTagBuilder
+{
+    // Tag name constants following OpenTelemetry workflow semantic conventions
+    // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md
+    internal const string TagWorkflowTaskName = "workflow.task.name";
+    internal const string TagWorkflowExecutionOutcome = "workflow.execution.outcome";
+    internal const string TagWorkflowExecutionState = "workflow.execution.state";
+    internal const string TagWorkflowPlatformName = "workflow.platform.name";
+    internal const string TagWorkflowTriggerType = "workflow.trigger.type";
+    internal const string TagErrorType = "error.type";
+
+    // Outcome values per semantic conventions
+    internal const string OutcomeSuccess = "success";
+    internal const string OutcomeFailure = "failure";
+
+    // State values per semantic conventions
+    internal const string StatePending = "pending";
+    internal const string StateExecuting = "executing";
+    internal const string StateCompleted = "completed";
+
+    // Platform name constant
+    internal const string PlatformHangfire = "hangfire";
+
+    // Trigger type constants
+    internal const string TriggerTypeCron = "cron";
+    internal const string TriggerTypeApi = "api";
+
+    /// <summary>
+    /// Creates a tag list with common job metadata following workflow semantic conventions.
+    /// Includes required workflow.task.name and recommended workflow.platform.name.
+    /// Also includes custom Hangfire-specific attributes (job.type, job.method).
+    /// </summary>
+    /// <param name="job">The Hangfire job.</param>
+    /// <returns>Tag list with common job tags.</returns>
+    public static TagList BuildCommonTags(Job job)
+    {
+        var tags = new TagList
+        {
+            GetTaskName(job),
+            GetPlatformName(),
+        };
+        return tags;
+    }
+
+    /// <summary>
+    /// Creates a tag list representing workflow execution state transitions.
+    /// Includes required workflow.task.name, workflow.execution.state, and workflow.trigger.type tags,
+    /// recommended workflow.platform.name, and conditionally required error.type.
+    /// </summary>
+    /// <param name="job">The Hangfire job.</param>
+    /// <param name="workflowState">The workflow state value.</param>
+    /// <param name="errorType">Optional error type to annotate failure states.</param>
+    /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
+    /// <returns>Tag list suitable for workflow.execution.status metric.</returns>
+    public static TagList BuildStateTags(Job job, string workflowState, string? errorType, string? recurringJobId)
+    {
+        var tags = new TagList
+        {
+            GetTaskName(job),
+            GetPlatformName(),
+            GetState(workflowState),
+            GetTriggerType(recurringJobId),
+        };
+
+        if (!string.IsNullOrEmpty(errorType))
+        {
+            tags.Add(new KeyValuePair<string, object?>(TagErrorType, errorType));
+        }
+
+        return tags;
+    }
+
+    /// <summary>
+    /// Maps Hangfire state names to workflow semantic convention state values.
+    /// </summary>
+    /// <param name="hangfireState">Hangfire state name.</param>
+    /// <returns>Mapped workflow state value, or <see langword="null"/> if the state is not recognized.</returns>
+    public static string? MapWorkflowState(string? hangfireState)
+    {
+        if (hangfireState == ScheduledState.StateName ||
+            hangfireState == EnqueuedState.StateName ||
+            hangfireState == AwaitingState.StateName)
+        {
+            return StatePending;
+        }
+
+        if (hangfireState == ProcessingState.StateName)
+        {
+            return StateExecuting;
+        }
+
+        if (hangfireState == SucceededState.StateName ||
+            hangfireState == DeletedState.StateName ||
+            hangfireState == FailedState.StateName)
+        {
+            return StateCompleted;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Creates a tag list with execution result tags following workflow semantic conventions.
+    /// Includes required attributes (workflow.task.name, workflow.execution.outcome),
+    /// recommended attributes (workflow.platform.name),
+    /// conditionally required attributes (error.type if failed)
+    /// </summary>
+    /// <param name="job">The Hangfire job.</param>
+    /// <param name="exception">The exception, if any occurred.</param>
+    /// <returns>Tag list with execution result tags.</returns>
+    public static TagList BuildExecutionTags(Job job, Exception? exception)
+    {
+        var tags = new TagList
+        {
+            GetTaskName(job),
+            GetPlatformName(),
+            GetOutcome(exception),
+        };
+
+        // Conditionally Required: error.type (if and only if the task run failed)
+        if (exception is not null)
+        {
+            tags.Add(GetErrorType(exception));
+        }
+
+        return tags;
+    }
+
+    /// <summary>
+    /// Creates a tag list for workflow.execution.errors metric following workflow semantic conventions.
+    /// Includes required attributes (error.type, workflow.task.name),
+    /// recommended attributes (workflow.platform.name).
+    /// </summary>
+    /// <param name="job">The Hangfire job.</param>
+    /// <param name="exception">The exception that occurred.</param>
+    /// <returns>Tag list with error tags.</returns>
+    public static TagList BuildErrorTags(Job job, Exception exception)
+    {
+        var tags = new TagList
+        {
+            GetErrorType(exception),
+            GetTaskName(job),
+            GetPlatformName(),
+        };
+
+        return tags;
+    }
+
+    // Required workflow attributes
+    private static KeyValuePair<string, object?> GetTaskName(Job job) =>
+        new(TagWorkflowTaskName, job.ToString() ?? "unknown");
+
+    private static KeyValuePair<string, object?> GetOutcome(Exception? exception) =>
+        new(TagWorkflowExecutionOutcome, exception is null ? OutcomeSuccess : OutcomeFailure);
+
+    private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId)
+    {
+        // Check if job was triggered by a recurring job (cron)
+        if (!string.IsNullOrEmpty(recurringJobId))
+        {
+            return new(TagWorkflowTriggerType, TriggerTypeCron);
+        }
+
+        // Default to API trigger (fire-and-forget, scheduled, continuations)
+        return new(TagWorkflowTriggerType, TriggerTypeApi);
+    }
+
+    // Recommended workflow attributes
+    private static KeyValuePair<string, object?> GetPlatformName() =>
+        new(TagWorkflowPlatformName, PlatformHangfire);
+
+    private static KeyValuePair<string, object?> GetState(string workflowState) =>
+        new(TagWorkflowExecutionState, workflowState);
+
+    // Conditionally required workflow attributes
+    private static KeyValuePair<string, object?> GetErrorType(Exception exception)
+    {
+        var loggedException = exception;
+
+        if (loggedException is JobPerformanceException pe)
+        {
+            loggedException = pe.InnerException;
+        }
+
+        return new KeyValuePair<string, object?>(TagErrorType, loggedException.GetType().FullName ?? loggedException.GetType().Name);
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs
new file mode 100644
index 0000000000..efb629a493
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs
@@ -0,0 +1,66 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using OpenTelemetry.Instrumentation.Hangfire.Implementation;
+using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Metrics;
+
+/// <summary>
+/// Extension methods to simplify registering of Hangfire metrics instrumentation.
+/// </summary>
+public static class MeterProviderBuilderExtensions
+{
+    /// <summary>
+    /// Enables Hangfire metrics instrumentation.
+    /// </summary>
+    /// <param name="builder"><see cref="MeterProviderBuilder"/> being configured.</param>
+    /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
+    public static MeterProviderBuilder AddHangfireInstrumentation(
+        this MeterProviderBuilder builder)
+        => AddHangfireInstrumentation(builder, name: null, configure: null);
+
+    /// <summary>
+    /// Enables Hangfire metrics instrumentation.
+    /// </summary>
+    /// <param name="builder"><see cref="MeterProviderBuilder"/> being configured.</param>
+    /// <param name="configure">Callback action for configuring <see cref="HangfireInstrumentationOptions"/>.</param>
+    /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
+    public static MeterProviderBuilder AddHangfireInstrumentation(
+        this MeterProviderBuilder builder,
+        Action<HangfireInstrumentationOptions>? configure)
+        => AddHangfireInstrumentation(builder, name: null, configure);
+
+    /// <summary>
+    /// Enables Hangfire metrics instrumentation.
+    /// </summary>
+    /// <param name="builder"><see cref="MeterProviderBuilder"/> being configured.</param>
+    /// <param name="name">Name which is used when retrieving options.</param>
+    /// <param name="configure"><see cref="HangfireInstrumentationOptions"/> configuration options.</param>
+    /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
+    public static MeterProviderBuilder AddHangfireInstrumentation(
+        this MeterProviderBuilder builder,
+        string? name,
+        Action<HangfireInstrumentationOptions>? configure)
+    {
+        Guard.ThrowIfNull(builder);
+
+        name ??= Options.DefaultName;
+
+        if (configure != null)
+        {
+            builder.ConfigureServices(services => services.Configure(name, configure));
+        }
+
+        builder.AddMeter(HangfireMetrics.MeterName);
+
+        return builder.AddInstrumentation(sp =>
+        {
+            var options = sp.GetRequiredService<IOptionsMonitor<HangfireInstrumentationOptions>>().Get(name);
+            return new HangfireMetricsInstrumentation(options);
+        });
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj b/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj
index 98e454f467..1f3d8222e6 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj
@@ -5,7 +5,6 @@
     <Description>OpenTelemetry Hangfire Instrumentation.</Description>
     <PackageTags>$(PackageTags);Hangfire</PackageTags>
     <MinVerTagPrefix>Instrumentation.Hangfire-</MinVerTagPrefix>
-    <SignAssembly>false</SignAssembly>
   </PropertyGroup>
 
   <!-- Do not run Package Baseline Validation as this package has never released a stable version.
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index f24d1306ee..1307428e8b 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -13,10 +13,14 @@ This is an
 [Instrumentation Library](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#instrumentation-library),
 which instruments
 [Hangfire](https://www.nuget.org/packages/Hangfire/)
-and collects telemetry about BackgroundJob.
+and collects traces and metrics about BackgroundJob executions.
 
 ## Steps to enable OpenTelemetry.Instrumentation.Hangfire
 
+> [!NOTE]
+> The following steps show how to enable **tracing**. For metrics, see the
+> [Metrics](#metrics) section below.
+
 ### Step 1: Install and configure Hangfire
 
 [Getting Started](https://docs.hangfire.io/en/latest/getting-started/index.html)
@@ -160,7 +164,194 @@ using var tracerProvider = Sdk
     .Build();
 ```
 
+## Metrics
+
+This instrumentation library collects metrics following the OpenTelemetry
+[workflow semantic conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md).
+In Hangfire, each background job execution is modeled as a **workflow task execution**.
+
+### Enabling Metrics
+
+Metrics are enabled by adding Hangfire instrumentation to the `MeterProviderBuilder`:
+
+```csharp
+using OpenTelemetry.Metrics;
+
+var meterProvider = Sdk.CreateMeterProviderBuilder()
+    .AddHangfireInstrumentation()
+    .AddConsoleExporter()
+    .Build();
+```
+
+The above example also sets up the OpenTelemetry Console exporter, which requires
+adding the package
+[`OpenTelemetry.Exporter.Console`](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/src/OpenTelemetry.Exporter.Console/README.md)
+to the application.
+
+### Enabling both Traces and Metrics
+
+To collect both traces and metrics from Hangfire:
+
+```csharp
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Trace;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .WithTracing(tracing => tracing
+        .AddHangfireInstrumentation()
+        .AddOtlpExporter())
+    .WithMetrics(metrics => metrics
+        .AddHangfireInstrumentation()
+        .AddOtlpExporter());
+```
+
+### Metrics Configuration
+
+The same `HangfireInstrumentationOptions` class is used to configure both tracing
+and metrics behavior.
+
+#### RecordQueueLatency
+
+By default, the instrumentation records only execution metrics. To also track how long
+jobs spend waiting in the queue before execution, enable the `RecordQueueLatency` option:
+
+```csharp
+var meterProvider = Sdk.CreateMeterProviderBuilder()
+    .AddHangfireInstrumentation(options =>
+    {
+        options.RecordQueueLatency = true;
+    })
+    .AddConsoleExporter()
+    .Build();
+```
+
+> [!WARNING]
+> Enabling `RecordQueueLatency` requires an additional database query per job execution
+> to retrieve the enqueue timestamp. In high-throughput scenarios, this may impact
+> performance.
+
+### Available Metrics
+
+The following metrics are emitted by this instrumentation:
+
+#### workflow.execution.count
+
+The number of task executions which have been initiated.
+
+| Units          | Instrument Type | Value Type |
+|----------------|-----------------|------------|
+| `{executions}` | Counter         | `Int64`    |
+
+**Attributes:**
+
+| Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
+|-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
+| `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`   |
+| `workflow.execution.outcome`  | string | The outcome of executing the task             | Required                 | `success`, `failure`    |
+| `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
+
+¹ Required if and only if the task execution failed.
+
+#### workflow.execution.duration
+
+Duration of an execution grouped by task and result.
+
+| Units | Instrument Type | Value Type |
+|-------|-----------------|------------|
+| `s`   | Histogram       | `Double`   |
+
+**Attributes:**
+
+Uses the same attributes as `workflow.execution.count`.
+
+#### workflow.execution.status
+
+The number of actively running tasks grouped by task and the current state.
+
+| Units          | Instrument Type  | Value Type |
+|----------------|------------------|------------|
+| `{executions}` | UpDownCounter    | `Int64`    |
+
+> [!NOTE]
+> This metric tracks the current state of job executions. When a job transitions
+> to a new state, the previous state is decremented and the new state is incremented.
+
+**Attributes:**
+
+| Attribute                     | Type   | Description                                   | Requirement Level        | Values                                    |
+|-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------------------------|
+| `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`                     |
+| `workflow.execution.state`    | string | Current state of the execution                | Required                 | `pending`, `executing`, `completed`       |
+| `workflow.trigger.type`       | string | Type of trigger that initiated the execution  | Required                 | `api`, `cron`                             |
+| `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`                                |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name                       |
+
+¹ Required if and only if the task execution failed.
+
+**Hangfire State Mapping:**
+
+Hangfire job states are mapped to workflow semantic convention states as follows:
+
+| Hangfire State                     | Workflow State |
+|------------------------------------|----------------|
+| Scheduled, Enqueued, Awaiting      | `pending`      |
+| Processing                         | `executing`    |
+| Succeeded, Failed, Deleted         | `completed`    |
+
+#### workflow.execution.errors
+
+The number of errors encountered in task executions.
+
+| Units     | Instrument Type | Value Type |
+|-----------|-----------------|------------|
+| `{error}` | Counter         | `Int64`    |
+
+**Attributes:**
+
+| Attribute                     | Type   | Description                                   | Requirement Level | Values                  |
+|-------------------------------|--------|-----------------------------------------------|-------------------|-------------------------|
+| `error.type`                  | string | The type of error that occurred               | Required          | Exception type name     |
+| `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required          | e.g., `MyJob.Execute`   |
+| `workflow.platform.name`      | string | The workflow platform being used              | Recommended       | `hangfire`              |
+
+#### hangfire.queue.latency
+
+Time tasks spend waiting in queue before execution starts. This is a Hangfire-specific
+metric not part of the standard workflow conventions.
+
+| Units | Instrument Type | Value Type |
+|-------|-----------------|------------|
+| `s`   | Histogram       | `Double`   |
+
+> [!NOTE]
+> This metric is only recorded when `RecordQueueLatency` option is enabled.
+
+**Attributes:**
+
+| Attribute                     | Type   | Description                                   | Requirement Level | Values                  |
+|-------------------------------|--------|-----------------------------------------------|-------------------|-------------------------|
+| `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required          | e.g., `MyJob.Execute`   |
+| `workflow.platform.name`      | string | The workflow platform being used              | Recommended       | `hangfire`              |
+
+### Semantic Conventions
+
+This instrumentation follows the OpenTelemetry semantic conventions for workflows:
+
+- **workflow.platform.name**: Always set to `"hangfire"`
+- **workflow.task.name**: Derived from the Hangfire job method (e.g., `ClassName.MethodName`)
+- **workflow.trigger.type**: Set to `"cron"` for recurring jobs, `"api"` for fire-and-forget,
+  scheduled, and continuation jobs
+- **workflow.execution.outcome**: Set to `"success"` when jobs complete without errors,
+  `"failure"` when an exception is thrown
+- **workflow.execution.state**: Maps Hangfire states to semantic convention states
+  (see table above)
+- **error.type**: Set to the full type name of the exception when a job fails
+
 ## References
 
 * [OpenTelemetry Project](https://opentelemetry.io/)
 * [Hangfire Project](https://www.hangfire.io/)
+* [OpenTelemetry Workflow Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md)
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
new file mode 100644
index 0000000000..ac77b2d334
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
@@ -0,0 +1,14 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
+
+/// <summary>
+/// Custom exception type for testing error.type differentiation.
+/// </summary>
+internal class CustomTestException : Exception
+{
+    public CustomTestException(string message) : base(message)
+    {
+    }
+}
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
index 614882d572..6f6173acad 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
@@ -13,6 +13,15 @@ public HangfireFixture()
     {
         GlobalConfiguration.Configuration
             .UseMemoryStorage();
+
+        // Remove AutomaticRetryAttribute from global filters for tests
+        // This ensures jobs fail immediately without retries, allowing state transitions to be tested
+        var retryFilter = GlobalJobFilters.Filters.FirstOrDefault(f => f.Instance is AutomaticRetryAttribute);
+        if (retryFilter != null)
+        {
+            GlobalJobFilters.Filters.Remove(retryFilter.Instance);
+        }
+
         this.Server = new BackgroundJobServer();
         this.MonitoringApi = JobStorage.Current.GetMonitoringApi();
     }
@@ -21,6 +30,40 @@ public HangfireFixture()
 
     public IMonitoringApi MonitoringApi { get; }
 
+    /// <summary>
+    /// Waits for a Hangfire job to be processed (complete processing state).
+    /// </summary>
+    /// <param name="jobId">The ID of the job to wait for.</param>
+    /// <param name="timeToWaitInSeconds">Maximum time to wait in seconds.</param>
+    /// <returns>A task that completes when the job is processed or the timeout expires.</returns>
+    public async Task WaitJobProcessedAsync(string jobId, int timeToWaitInSeconds)
+    {
+        var timeout = TimeSpan.FromSeconds(timeToWaitInSeconds);
+        using var cts = new CancellationTokenSource(timeout);
+
+        string[] states = ["Enqueued", "Processing"];
+
+        while (!Completed() && !cts.IsCancellationRequested)
+        {
+            await Task.Delay(500);
+        }
+
+        bool Completed()
+        {
+            var jobDetails = this.MonitoringApi.JobDetails(jobId);
+
+            if (jobDetails == null)
+            {
+                return false;
+            }
+
+            // Copy the history to an array to avoid exception if the collection is modified while iterating
+            var history = jobDetails.History.ToArray();
+
+            return !history.All(h => states.Contains(h.StateName));
+        }
+    }
+
     public void Dispose()
     {
         this.Server.Dispose();
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireInstrumentationJobFilterAttributeTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireInstrumentationJobFilterAttributeTests.cs
index 1fed8d0f0c..332c424e78 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireInstrumentationJobFilterAttributeTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireInstrumentationJobFilterAttributeTests.cs
@@ -32,7 +32,7 @@ public async Task Should_Create_Activity()
 
         // Act
         var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
-        await this.WaitJobProcessedAsync(jobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         // Assert
         Assert.Single(exportedItems, i => (i.GetTagItem("job.id") as string) == jobId);
@@ -53,7 +53,7 @@ public async Task Should_Create_Activity_With_Status_Error_When_Job_Failed()
 
         // Act
         var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
-        await this.WaitJobProcessedAsync(jobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         // Assert
         Assert.Single(exportedItems, i => (i.GetTagItem("job.id") as string) == jobId);
@@ -77,7 +77,7 @@ public async Task Should_Create_Activity_With_Exception_Event_When_Job_Failed_An
 
         // Act
         var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
-        await this.WaitJobProcessedAsync(jobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         // Assert
         Assert.Single(exportedItems, i => (i.GetTagItem("job.id") as string) == jobId);
@@ -101,7 +101,7 @@ public async Task Should_Create_Activity_Without_Exception_Event_When_Job_Failed
 
         // Act
         var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
-        await this.WaitJobProcessedAsync(jobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         // Assert
         Assert.Single(exportedItems, i => (i.GetTagItem("job.id") as string) == jobId);
@@ -126,7 +126,7 @@ public async Task Should_Create_Activity_With_Custom_DisplayName()
 
         // Act
         var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
-        await this.WaitJobProcessedAsync(jobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         // Assert
         Assert.Single(exportedItems, i => (i.GetTagItem("job.id") as string) == jobId);
@@ -162,7 +162,7 @@ public async Task Should_Respect_Filter_Option(string filter, bool shouldRecord)
 
         // Act
         var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
-        await this.WaitJobProcessedAsync(jobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         // Assert
         Assert.Single(processedItems);
@@ -187,40 +187,12 @@ public async Task Should_Not_Inject_Invalid_Context()
 
         // Act
         var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
-        await this.WaitJobProcessedAsync(jobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         // Assert
         Assert.All(listener.Messages, args => Assert.NotEqual("FailedToInjectActivityContext", args.EventName));
     }
 
-    private async Task WaitJobProcessedAsync(string jobId, int timeToWaitInSeconds)
-    {
-        var timeout = TimeSpan.FromSeconds(timeToWaitInSeconds);
-        using var cts = new CancellationTokenSource(timeout);
-
-        string[] states = ["Enqueued", "Processing"];
-
-        while (!Completed() && !cts.IsCancellationRequested)
-        {
-            await Task.Delay(500);
-        }
-
-        bool Completed()
-        {
-            var jobDetails = this.hangfireFixture.MonitoringApi.JobDetails(jobId);
-
-            if (jobDetails == null)
-            {
-                return false;
-            }
-
-            // Copy the history to an array to avoid exception if the collection is modified while iterating
-            var history = jobDetails.History.ToArray();
-
-            return !history.All(h => states.Contains(h.StateName));
-        }
-    }
-
     private class OpenTelemetryEventListener : EventListener
     {
         private const string EventSourceName = "OpenTelemetry-Api";
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs
new file mode 100644
index 0000000000..0aea024865
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs
@@ -0,0 +1,208 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire;
+using OpenTelemetry.Instrumentation.Hangfire.Implementation;
+using OpenTelemetry.Instrumentation.Hangfire.Tests.Utils;
+using OpenTelemetry.Metrics;
+using Xunit;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
+
+[Collection("Hangfire")]
+public class HangfireMetricsErrorTests : IClassFixture<HangfireFixture>
+{
+    private readonly HangfireFixture hangfireFixture;
+
+    public HangfireMetricsErrorTests(HangfireFixture hangfireFixture)
+    {
+        this.hangfireFixture = hangfireFixture;
+    }
+
+    [Fact]
+    public async Task Should_Record_ExecutionErrors_Metric_When_Job_Fails()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        AssertUtils.AssertHasMetricPoints(errorMetric);
+        Assert.Equal("{error}", errorMetric!.Unit);
+        Assert.Equal(MetricType.LongSum, errorMetric.MetricType);
+
+        var metricPoints = errorMetric.ToMetricPointList();
+
+        var metricPoint = metricPoints.First();
+        var sum = metricPoint.GetSumLong();
+        Assert.True(sum >= 1, $"Expected workflow.execution.errors sum >= 1, got {sum}");
+
+        // Validate required tags
+        AssertUtils.AssertTagContains(metricPoint, HangfireTagBuilder.TagErrorType, "Exception");
+        AssertUtils.AssertTagContains(metricPoint, HangfireTagBuilder.TagWorkflowTaskName, "TestJob.ThrowException");
+
+        // Validate recommended tags
+        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName, HangfireTagBuilder.PlatformHangfire);
+    }
+
+    [Fact]
+    public async Task Should_Not_Record_ExecutionErrors_Metric_When_Job_Succeeds()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        AssertUtils.AssertMetricNotRecordedOrZero(exportedItems, HangfireMetrics.ExecutionErrorsMetricName);
+    }
+
+    [Fact]
+    public async Task Should_Increment_ExecutionErrors_Counter_For_Multiple_Failures()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Execute multiple failing jobs
+        var jobId1 = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        var jobId2 = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        var jobId3 = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId1, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId2, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId3, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        AssertUtils.AssertHasMetricPoints(errorMetric);
+
+        var metricPoints = errorMetric!.ToMetricPointList();
+        var totalErrors = metricPoints.Sum(mp => mp.GetSumLong());
+        Assert.True(totalErrors >= 3, $"Expected at least 3 errors, got {totalErrors}");
+    }
+
+    [Fact]
+    public async Task Should_Record_Different_Error_Types_Separately()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Execute jobs with different exception types
+        var jobId1 = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        var jobId2 = BackgroundJob.Enqueue<TestJobWithCustomException>(x => x.ThrowCustomException());
+
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId1, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId2, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        AssertUtils.AssertHasMetricPoints(errorMetric);
+        var metricPoints = errorMetric!.ToMetricPointList();
+
+        // Should have at least 2 different metric points for different error types
+        var distinctErrorTypes = metricPoints
+            .Select(mp => mp.GetTagValue(HangfireTagBuilder.TagErrorType))
+            .Distinct()
+            .ToList();
+
+        Assert.True(distinctErrorTypes.Count >= 2, $"Expected at least 2 distinct error types, got {distinctErrorTypes.Count}");
+        Assert.Contains(distinctErrorTypes, et => et != null && et.Contains("Exception"));
+        Assert.Contains(distinctErrorTypes, et => et != null && et.Contains("CustomTestException"));
+    }
+
+    [Fact]
+    public async Task Should_Track_Success_And_Failure_Separately()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Execute one successful and two failed jobs
+        var successJobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        var failJobId1 = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        var failJobId2 = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+
+        await this.hangfireFixture.WaitJobProcessedAsync(successJobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(failJobId1, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(failJobId2, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - errors metric should only count the 2 failures
+        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        AssertUtils.AssertHasMetricPoints(errorMetric);
+        var metricPoints = errorMetric!.ToMetricPointList();
+
+        var totalErrors = metricPoints.Sum(mp => mp.GetSumLong());
+        Assert.True(totalErrors >= 2, $"Expected at least 2 errors, got {totalErrors}");
+
+        // All error metrics should have error.type tag
+        foreach (var point in metricPoints)
+        {
+            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagErrorType);
+        }
+    }
+
+    [Fact]
+    public async Task Should_Record_All_Required_And_Recommended_Tags()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        AssertUtils.AssertHasMetricPoints(errorMetric);
+        var metricPoints = errorMetric!.ToMetricPointList();
+
+        var metricPoint = metricPoints.First();
+
+        // Required tags per semantic conventions
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagErrorType);
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
+
+        // Recommended tags per semantic conventions
+        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName, HangfireTagBuilder.PlatformHangfire);
+    }
+}
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
new file mode 100644
index 0000000000..172e759257
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -0,0 +1,387 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire;
+using OpenTelemetry.Instrumentation.Hangfire.Implementation;
+using OpenTelemetry.Instrumentation.Hangfire.Tests.Utils;
+using OpenTelemetry.Metrics;
+using Xunit;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
+
+[Collection("Hangfire")]
+public class HangfireMetricsTests : IClassFixture<HangfireFixture>
+{
+    private readonly HangfireFixture hangfireFixture;
+
+    public HangfireMetricsTests(HangfireFixture hangfireFixture)
+    {
+        this.hangfireFixture = hangfireFixture;
+    }
+
+    [Fact]
+    public async Task Should_Record_ExecutionCount_Metric_When_Job_Executes()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var executionCountMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionCountMetricName);
+        AssertUtils.AssertHasMetricPoints(executionCountMetric);
+        Assert.Equal("{executions}", executionCountMetric!.Unit);
+        Assert.Equal(MetricType.LongSum, executionCountMetric.MetricType);
+
+        var metricPoints = executionCountMetric.ToMetricPointList();
+        var sum = metricPoints.First().GetSumLong();
+        Assert.True(sum >= 1, $"Expected workflow.execution.count sum >= 1, got {sum}");
+
+        // Validate tags
+        var metricPoint = metricPoints.First();
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+    }
+
+    [Fact]
+    public async Task Should_Record_ExecutionDuration_Metric_For_Successful_Job()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
+        Assert.Equal("s", durationMetric!.Unit);
+        Assert.Equal(MetricType.Histogram, durationMetric.MetricType);
+
+        var metricPoints = durationMetric.ToMetricPointList();
+        var metricPoint = metricPoints.First();
+
+        var count = metricPoint.GetHistogramCount();
+        var sum = metricPoint.GetHistogramSum();
+
+        Assert.True(count >= 1, $"Expected histogram count >= 1, got {count}");
+        Assert.True(sum >= 0, $"Expected histogram sum >= 0, got {sum}");
+
+        // Validate tags for successful execution
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+
+        // Error type should NOT be present for successful execution
+        AssertUtils.AssertHasNoTag(metricPoint, HangfireTagBuilder.TagErrorType);
+    }
+
+    [Fact]
+    public async Task Should_Record_ExecutionDuration_Metric_With_ErrorType_For_Failed_Job()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
+
+        var metricPoints = durationMetric!.ToMetricPointList();
+        var metricPoint = metricPoints.First();
+
+        var count = metricPoint.GetHistogramCount();
+        Assert.True(count >= 1, $"Expected histogram count >= 1, got {count}");
+
+        // Validate tags for failed execution
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeFailure);
+
+        // Error type is conditionally required for failed execution
+        AssertUtils.AssertTagContains(metricPoint, HangfireTagBuilder.TagErrorType, "Exception");
+    }
+
+    [Fact]
+    public async Task Should_Record_QueueLatency_Metric_When_Enabled()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.RecordQueueLatency = true;
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
+        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
+        Assert.Equal("s", queueLatencyMetric!.Unit);
+        Assert.Equal(MetricType.Histogram, queueLatencyMetric.MetricType);
+
+        var metricPoints = queueLatencyMetric.ToMetricPointList();
+        var metricPoint = metricPoints.First();
+
+        var count = metricPoint.GetHistogramCount();
+        var sum = metricPoint.GetHistogramSum();
+
+        Assert.True(count >= 1, $"Expected histogram count >= 1, got {count}");
+        Assert.True(sum >= 0, $"Expected queue latency sum >= 0, got {sum}");
+
+        // Validate tags
+        AssertUtils.AssertHasTag(metricPoint, "workflow.task.name");
+        AssertUtils.AssertHasTag(metricPoint, "workflow.platform.name");
+    }
+
+    [Fact]
+    public async Task Should_Record_ExecutionStatus_States_For_Successful_Job()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var statusMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
+        AssertUtils.AssertHasMetricPoints(statusMetric);
+        Assert.Equal(MetricType.LongSumNonMonotonic, statusMetric!.MetricType);
+
+        var metricPoints = statusMetric.ToMetricPointList();
+
+        // Verify all points have required tags
+        foreach (var point in metricPoints)
+        {
+            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowTaskName);
+            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowPlatformName);
+            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowExecutionState);
+            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowTriggerType);
+        }
+
+        // Verify state transitions balance out to final state
+        var pendingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending)?.GetSumLong() ?? 0;
+        var executingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting)?.GetSumLong() ?? 0;
+        var completedSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted)?.GetSumLong() ?? 0;
+
+        Assert.Equal(0, pendingSum);
+        Assert.Equal(0, executingSum);
+        Assert.Equal(1, completedSum);
+
+        // Verify completed state has correct attributes
+        var completedPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted);
+        Assert.NotNull(completedPoint);
+
+        AssertUtils.AssertHasNoTag(completedPoint.Value, HangfireTagBuilder.TagErrorType);
+        AssertUtils.AssertHasTagValue(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeApi);
+    }
+
+    [Fact]
+    public async Task Should_Record_ExecutionStatus_ErrorType_For_Failed_Job()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var statusMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
+        AssertUtils.AssertHasMetricPoints(statusMetric);
+        Assert.Equal(MetricType.LongSumNonMonotonic, statusMetric!.MetricType);
+
+        var metricPoints = statusMetric.ToMetricPointList();
+
+        // Verify state transitions balance out to final state (completed with error)
+        var pendingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending)?.GetSumLong() ?? 0;
+        var executingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting)?.GetSumLong() ?? 0;
+        var completedSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted)?.GetSumLong() ?? 0;
+
+        Assert.Equal(0, pendingSum);
+        Assert.Equal(0, executingSum);
+        Assert.Equal(1, completedSum);
+
+        // Find the completed state metric point (should have error type for failed job)
+        var completedPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted);
+        Assert.NotNull(completedPoint);
+
+        // Verify error type is present and contains exception information
+        AssertUtils.AssertTagContains(completedPoint.Value, HangfireTagBuilder.TagErrorType, "Exception");
+
+        // Verify trigger type
+        AssertUtils.AssertHasTagValue(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeApi);
+    }
+
+    [Fact]
+    public async Task Should_Record_All_Metrics_For_Multiple_Jobs()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.RecordQueueLatency = true;
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Execute multiple jobs
+        var jobId1 = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        var jobId2 = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        var jobId3 = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId1, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId2, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId3, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - All metric types should be present
+        exportedItems.GetMetric(HangfireMetrics.ExecutionCountMetricName);
+        exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
+        exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
+
+        // Verify execution.count has at least 3 executions
+        var executionCountMetric = exportedItems.First(m => m.Name == HangfireMetrics.ExecutionCountMetricName);
+        var executionCountPoints = executionCountMetric.ToMetricPointList();
+
+        var totalExecutions = executionCountPoints.Sum(mp => mp.GetSumLong());
+        Assert.True(totalExecutions >= 3, $"Expected at least 3 executions, got {totalExecutions}");
+    }
+
+    [Fact]
+    public async Task Should_Track_Success_And_Failure_Outcomes_Separately()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Execute one successful and one failed job
+        var successJobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        var failJobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+
+        await this.hangfireFixture.WaitJobProcessedAsync(successJobId, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(failJobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Check execution duration metric has both outcomes
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
+
+        var metricPoints = durationMetric!.ToMetricPointList();
+
+        // Verify success outcome exists without error type
+        var successPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+        Assert.NotNull(successPoint);
+        AssertUtils.AssertHasNoTag(successPoint.Value, HangfireTagBuilder.TagErrorType);
+
+        // Verify failure outcome exists with error type
+        var failurePoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeFailure);
+        Assert.NotNull(failurePoint);
+        AssertUtils.AssertHasTag(failurePoint.Value, HangfireTagBuilder.TagErrorType);
+    }
+
+    [Fact]
+    public async Task Should_Record_TriggerType_Cron_For_Recurring_Jobs()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Create a recurring job and trigger it manually
+        RecurringJob.AddOrUpdate("test-recurring-job", () => new TestJob().Execute(), Cron.Minutely());
+        var jobId = RecurringJob.TriggerJob("test-recurring-job");
+
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Check execution status metric has cron trigger type
+        var statusMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
+        AssertUtils.AssertHasMetricPoints(statusMetric);
+        var metricPoints = statusMetric!.ToMetricPointList();
+
+        // Find completed state metric point
+        var completedPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted);
+
+        Assert.NotNull(completedPoint);
+
+        // Verify trigger type is 'cron' for recurring jobs
+        AssertUtils.AssertHasTagValue(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeCron);
+
+        // Cleanup
+        RecurringJob.RemoveIfExists("test-recurring-job");
+    }
+
+    [Fact]
+    public void AddHangfireInstrumentation_Should_Register_Meter()
+    {
+        // Arrange & Act
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Force a job to generate metrics
+        BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+
+        // Assert - The meter should be registered and ready to emit metrics
+        // We don't need to wait for job completion, just verify the provider was configured
+        Assert.NotNull(meterProvider);
+    }
+}
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
new file mode 100644
index 0000000000..8d7a2c0eb1
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
@@ -0,0 +1,225 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire;
+using OpenTelemetry.Instrumentation.Hangfire.Implementation;
+using OpenTelemetry.Instrumentation.Hangfire.Tests.Utils;
+using OpenTelemetry.Metrics;
+using Xunit;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
+
+[Collection("Hangfire")]
+public class HangfireQueueLatencyTests : IClassFixture<HangfireFixture>
+{
+    private readonly HangfireFixture hangfireFixture;
+
+    public HangfireQueueLatencyTests(HangfireFixture hangfireFixture)
+    {
+        this.hangfireFixture = hangfireFixture;
+    }
+
+    [Fact]
+    public async Task Should_NOT_Record_QueueLatency_Metric_By_Default()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation() // Default: RecordQueueLatency = false
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Queue latency metric should NOT be present
+        var queueLatencyMetric = exportedItems.FirstOrDefault(m => m.Name == HangfireMetrics.QueueLatencyMetricName);
+        Assert.Null(queueLatencyMetric);
+    }
+
+    [Fact]
+    public async Task Should_Record_QueueLatency_Metric_When_Enabled()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.RecordQueueLatency = true;
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Queue latency metric should be present
+        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
+        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
+        Assert.Equal("s", queueLatencyMetric!.Unit);
+        Assert.Equal(MetricType.Histogram, queueLatencyMetric.MetricType);
+
+        var metricPoints = queueLatencyMetric.ToMetricPointList();
+        var metricPoint = metricPoints.First();
+
+        var count = metricPoint.GetHistogramCount();
+        var sum = metricPoint.GetHistogramSum();
+
+        Assert.True(count >= 1, $"Expected histogram count >= 1, got {count}");
+        Assert.True(sum >= 0, $"Expected queue latency sum >= 0, got {sum}");
+
+        // Validate tags
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
+    }
+
+    [Fact]
+    public async Task Should_NOT_Record_QueueLatency_Metric_When_Explicitly_Disabled()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.RecordQueueLatency = false; // Explicitly disabled
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Queue latency metric should NOT be present
+        var queueLatencyMetric = exportedItems.FirstOrDefault(m => m.Name == HangfireMetrics.QueueLatencyMetricName);
+        Assert.Null(queueLatencyMetric);
+    }
+
+    [Fact]
+    public async Task Should_Record_Accurate_QueueLatency_For_Retried_Job()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.RecordQueueLatency = true;
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Create a job that fails first, then gets retried
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        // Clear metrics from first execution
+        exportedItems.Clear();
+
+        // Manually requeue the job (simulating retry)
+        BackgroundJob.Requeue(jobId);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Queue latency should reflect time since re-enqueue, not original creation
+        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
+        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
+
+        var metricPoints = queueLatencyMetric!.ToMetricPointList();
+        if (metricPoints.Count != 0)
+        {
+            var metricPoint = metricPoints.First();
+            var sum = metricPoint.GetHistogramSum();
+
+            // Queue latency should be small (< 10 seconds) since we just re-enqueued
+            // If it used CreatedAt, it would be much larger
+            Assert.True(sum < 10, $"Expected queue latency < 10 seconds for retry, got {sum}");
+        }
+    }
+
+    [Fact]
+    public async Task Should_Record_QueueLatency_For_Multiple_Jobs()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.RecordQueueLatency = true;
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Execute multiple jobs
+        var jobId1 = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        var jobId2 = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        var jobId3 = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId1, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId2, 5);
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId3, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Queue latency metric should have multiple data points
+        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
+        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
+
+        var metricPoints = queueLatencyMetric!.ToMetricPointList();
+        Assert.NotEmpty(metricPoints);
+
+        // At least one metric point should exist (could be aggregated)
+        var metricPoint = metricPoints.First();
+        var count = metricPoint.GetHistogramCount();
+
+        Assert.True(count >= 3, $"Expected at least 3 queue latency measurements, got {count}");
+    }
+
+    [Fact]
+    public void Should_NOT_Register_QueueLatencyFilter_When_Disabled()
+    {
+        // Arrange
+        var options = new Trace.HangfireInstrumentationOptions
+        {
+            RecordQueueLatency = false,
+        };
+
+        // Act
+        using var instrumentation = new Implementation.HangfireMetricsInstrumentation(options);
+
+        var finalFilterCount = GlobalJobFilters.Filters.Count;
+
+        // Verify no HangfireQueueLatencyFilterAttribute is registered
+        var queueLatencyFilterExists = GlobalJobFilters.Filters
+            .Any(f => f.Instance is Implementation.HangfireQueueLatencyFilterAttribute);
+        Assert.False(queueLatencyFilterExists);
+    }
+
+    [Fact]
+    public void Should_Register_QueueLatencyFilter_When_Enabled()
+    {
+        // Arrange
+        var options = new Trace.HangfireInstrumentationOptions
+        {
+            RecordQueueLatency = true,
+        };
+
+        // Act
+        using var instrumentation = new Implementation.HangfireMetricsInstrumentation(options);
+
+        var finalFilterCount = GlobalJobFilters.Filters.Count;
+
+        // Verify HangfireQueueLatencyFilterAttribute IS registered
+        var queueLatencyFilterExists = GlobalJobFilters.Filters
+            .Any(f => f.Instance is Implementation.HangfireQueueLatencyFilterAttribute);
+        Assert.True(queueLatencyFilterExists);
+    }
+}
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/MetricPointExtensions.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/MetricPointExtensions.cs
new file mode 100644
index 0000000000..a3dcfcdaf9
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/MetricPointExtensions.cs
@@ -0,0 +1,84 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using OpenTelemetry.Metrics;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
+
+/// <summary>
+/// Extension methods for working with MetricPoint collections in tests.
+/// </summary>
+internal static class MetricPointExtensions
+{
+    /// <summary>
+    /// Filters metric points to those having the specified tag (with optional value matching).
+    /// </summary>
+    public static IEnumerable<MetricPoint> HavingTag(this IEnumerable<MetricPoint> metricPoints, string tagName, string? tagValue = null)
+    {
+        foreach (var point in metricPoints)
+        {
+            foreach (var tag in point.Tags)
+            {
+                if (tag.Key == tagName && (tagValue == null || tag.Value?.ToString() == tagValue))
+                {
+                    yield return point;
+                    break;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Finds the first metric point with the specified tag value.
+    /// </summary>
+    public static MetricPoint? FindFirstWithTag(this IEnumerable<MetricPoint> metricPoints, string tagName, string tagValue)
+    {
+        return metricPoints.HavingTag(tagName, tagValue).FirstOrDefault();
+    }
+
+    /// <summary>
+    /// Checks if a metric point has a specific tag with a specific value.
+    /// </summary>
+    public static bool HasTag(this MetricPoint metricPoint, string tagName, string tagValue)
+    {
+        foreach (var tag in metricPoint.Tags)
+        {
+            if (tag.Key == tagName)
+            {
+                return tag.Value?.ToString() == tagValue;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Gets the value of a tag from a metric point, or null if not present.
+    /// </summary>
+    public static string? GetTagValue(this MetricPoint metricPoint, string tagName)
+    {
+        foreach (var tag in metricPoint.Tags)
+        {
+            if (tag.Key == tagName)
+            {
+                return tag.Value?.ToString();
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Converts metric points from a metric to a list.
+    /// </summary>
+    public static List<MetricPoint> ToMetricPointList(this Metric metric)
+    {
+        var metricPoints = new List<MetricPoint>();
+        foreach (var mp in metric.GetMetricPoints())
+        {
+            metricPoints.Add(mp);
+        }
+
+        return metricPoints;
+    }
+}
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj
index a12781ff1c..d66cee4ff5 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj
@@ -5,8 +5,6 @@
     <TargetFrameworks>$(SupportedNetTargets)</TargetFrameworks>
     <TargetFrameworks Condition="$(OS) == 'Windows_NT'">$(TargetFrameworks);$(NetFrameworkMinimumSupportedVersion)</TargetFrameworks>
     <Description>Unit test project for OpenTelemetry Hangfire instrumentation.</Description>
-    <SignAssembly>false</SignAssembly>
-    <SkipStrongNameValidation>true</SkipStrongNameValidation>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/TestJobWithCustomException.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/TestJobWithCustomException.cs
new file mode 100644
index 0000000000..5295202a02
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/TestJobWithCustomException.cs
@@ -0,0 +1,16 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
+
+/// <summary>
+/// Test job class that throws a custom exception type.
+/// Used for testing error.type tag cardinality.
+/// </summary>
+internal class TestJobWithCustomException
+{
+    public void ThrowCustomException()
+    {
+        throw new CustomTestException("Test custom exception");
+    }
+}
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/AssertUtils.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/AssertUtils.cs
new file mode 100644
index 0000000000..8fdc550785
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/AssertUtils.cs
@@ -0,0 +1,94 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using OpenTelemetry.Metrics;
+using Xunit;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests.Utils;
+
+/// <summary>
+/// Utility methods for asserting metric properties in tests.
+/// </summary>
+internal static class AssertUtils
+{
+    /// <summary>
+    /// Asserts that a metric point has a tag with the specified key (tag exists and is not null).
+    /// </summary>
+    /// <param name="metricPoint">The metric point to check.</param>
+    /// <param name="tagKey">The tag key to look for.</param>
+    public static void AssertHasTag(MetricPoint metricPoint, string tagKey)
+    {
+        var tagValue = metricPoint.GetTagValue(tagKey);
+        Assert.NotNull(tagValue);
+    }
+
+    /// <summary>
+    /// Asserts that a metric point has a tag with the specified key and exact value.
+    /// </summary>
+    /// <param name="metricPoint">The metric point to check.</param>
+    /// <param name="tagKey">The tag key to look for.</param>
+    /// <param name="expectedValue">The expected tag value.</param>
+    public static void AssertHasTagValue(MetricPoint metricPoint, string tagKey, string expectedValue)
+    {
+        var tagValue = metricPoint.GetTagValue(tagKey);
+        Assert.Equal(expectedValue, tagValue);
+    }
+
+    /// <summary>
+    /// Asserts that a metric point has a tag with the specified key and that its value contains the specified substring.
+    /// </summary>
+    /// <param name="metricPoint">The metric point to check.</param>
+    /// <param name="tagKey">The tag key to look for.</param>
+    /// <param name="substring">The substring that should be present in the tag value.</param>
+    public static void AssertTagContains(MetricPoint metricPoint, string tagKey, string substring)
+    {
+        var tagValue = metricPoint.GetTagValue(tagKey);
+        Assert.NotNull(tagValue);
+        Assert.Contains(substring, tagValue);
+    }
+
+    /// <summary>
+    /// Asserts that a metric point does not have a tag with the specified key (tag is null).
+    /// </summary>
+    /// <param name="metricPoint">The metric point to check.</param>
+    /// <param name="tagKey">The tag key to look for.</param>
+    public static void AssertHasNoTag(MetricPoint metricPoint, string tagKey)
+    {
+        var tagValue = metricPoint.GetTagValue(tagKey);
+        Assert.Null(tagValue);
+    }
+
+    /// <summary>
+    /// Asserts that a metric with the specified name exists in the exported items.
+    /// </summary>
+    /// <param name="exportedItems">The list of exported metrics.</param>
+    /// <param name="metricName">The name of the metric to find.</param>
+    public static void AssertMetricExists(List<Metric> exportedItems, string metricName)
+    {
+        var metric = exportedItems.GetMetric(metricName);
+        Assert.NotNull(metric);
+    }
+
+    /// <summary>
+    /// Asserts that a metric either doesn't exist or has a sum of zero.
+    /// Useful for verifying that a counter metric was not incremented.
+    /// </summary>
+    /// <param name="exportedItems">The list of exported metrics.</param>
+    /// <param name="metricName">The name of the metric to check.</param>
+    public static void AssertMetricNotRecordedOrZero(List<Metric> exportedItems, string metricName)
+    {
+        var metric = exportedItems.GetMetric(metricName);
+        if (metric != null)
+        {
+            var metricPoints = metric.ToMetricPointList();
+            var sum = metricPoints.Sum(mp => mp.GetSumLong());
+            Assert.Equal(0, sum);
+        }
+    }
+
+    public static void AssertHasMetricPoints(Metric? metricPoints)
+    {
+        Assert.NotNull(metricPoints);
+        Assert.NotEmpty(metricPoints.ToMetricPointList());
+    }
+}
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs
new file mode 100644
index 0000000000..1aa0beda7f
--- /dev/null
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs
@@ -0,0 +1,20 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using OpenTelemetry.Metrics;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Tests.Utils;
+
+/// <summary>
+/// Extension methods for metric collections.
+/// </summary>
+internal static class MetricCollectionExtensions
+{
+    /// <summary>
+    /// Gets a metric with the specified name from the exported items.
+    /// </summary>
+    /// <param name="exportedItems">The list of exported metrics.</param>
+    /// <param name="metricName">The name of the metric to find.</param>
+    /// <returns>The found metric, or null if not found.</returns>
+    public static Metric? GetMetric(this List<Metric> exportedItems, string metricName) => exportedItems.FirstOrDefault(m => m.Name == metricName);
+}

From 08198ac3c5f0aa763c886e120093e248fd8d90ac Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Wed, 22 Oct 2025 15:10:16 -0400
Subject: [PATCH 02/48]  Align metrics with workflow semconv: use
 duration{state=pending}, move trigger.type to workflow-level metrics, add
 workflow.count

---
 .../HangfireInstrumentationOptions.cs         |   6 +-
 .../Implementation/HangfireMetrics.cs         |  44 +++--
 .../HangfireMetricsInstrumentation.cs         |   4 +-
 .../HangfireMetricsJobFilterAttribute.cs      |  36 +++-
 .../HangfireMetricsStateFilter.cs             |  21 +-
 ...HangfirePendingDurationFilterAttribute.cs} |  19 +-
 .../Implementation/HangfireTagBuilder.cs      |  90 +++++++--
 .../README.md                                 |  71 ++++---
 .../HangfireMetricsTests.cs                   |  66 ++++---
 .../HangfireQueueLatencyTests.cs              | 187 ++++++++++++------
 10 files changed, 369 insertions(+), 175 deletions(-)
 rename src/OpenTelemetry.Instrumentation.Hangfire/Implementation/{HangfireQueueLatencyFilterAttribute.cs => HangfirePendingDurationFilterAttribute.cs} (67%)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
index 2a931b2804..e50e4f6251 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
@@ -47,12 +47,14 @@ public class HangfireInstrumentationOptions
     public Func<BackgroundJob, bool>? Filter { get; set; }
 
     /// <summary>
-    /// Gets or sets a value indicating whether to record queue latency metrics.
+    /// Gets or sets a value indicating whether to record the pending state duration in metrics.
     /// </summary>
     /// <remarks>
-    /// When enabled, records the time jobs spend waiting in the queue before execution.
+    /// When enabled, records workflow.execution.duration with state="pending", representing
+    /// the time jobs spend waiting in the queue before execution starts.
     /// This requires an additional database call per job execution to retrieve the enqueue timestamp.
     /// Default is <see langword="false"/> to avoid performance impact in high-throughput scenarios.
+    /// When disabled, only execution duration (state="executing") is recorded.
     /// </remarks>
     public bool RecordQueueLatency { get; set; }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
index c34afbb2b3..0125fb9b41 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
@@ -12,18 +12,18 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal static class HangfireMetrics
 {
-    private static readonly Assembly Assembly = typeof(HangfireMetrics).Assembly;
-    private static readonly AssemblyName AssemblyName = Assembly.GetName();
-    internal static readonly string MeterName = AssemblyName.Name!;
-    private static readonly string InstrumentationVersion = Assembly.GetPackageVersion();
-
     // Metric name constants
     internal const string ExecutionCountMetricName = "workflow.execution.count";
     internal const string ExecutionDurationMetricName = "workflow.execution.duration";
     internal const string ExecutionStatusMetricName = "workflow.execution.status";
     internal const string ExecutionErrorsMetricName = "workflow.execution.errors";
+    internal const string WorkflowCountMetricName = "workflow.count";
 
-    internal const string QueueLatencyMetricName = "hangfire.queue.latency";
+    internal static readonly Assembly Assembly = typeof(HangfireMetrics).Assembly;
+    internal static readonly AssemblyName AssemblyName = Assembly.GetName();
+    internal static readonly string MeterName = AssemblyName.Name!;
+
+    private static readonly string InstrumentationVersion = Assembly.GetPackageVersion();
 
     /// <summary>
     /// The meter instance for all Hangfire metrics.
@@ -35,15 +35,22 @@ internal static class HangfireMetrics
     /// Follows OpenTelemetry workflow semantic conventions.
     /// </summary>
     public static readonly Counter<long> ExecutionCount =
-        Meter.CreateCounter<long>(ExecutionCountMetricName, unit: "{executions}",
+        Meter.CreateCounter<long>(
+            ExecutionCountMetricName,
+            unit: "{executions}",
             description: "The number of task executions which have been initiated.");
 
     /// <summary>
     /// Histogram for duration of an execution grouped by task, type and result.
     /// Follows OpenTelemetry workflow semantic conventions.
+    /// Records duration for different execution phases using workflow.execution.state attribute:
+    /// - state=pending: Time spent waiting in queue before execution.
+    /// - state=executing: Time spent in actual execution.
     /// </summary>
     public static readonly Histogram<double> ExecutionDuration =
-        Meter.CreateHistogram<double>(ExecutionDurationMetricName, unit: "s",
+        Meter.CreateHistogram<double>(
+            ExecutionDurationMetricName,
+            unit: "s",
             description: "Duration of an execution grouped by task, type and result.");
 
     /// <summary>
@@ -51,7 +58,9 @@ internal static class HangfireMetrics
     /// Follows OpenTelemetry workflow semantic conventions.
     /// </summary>
     public static readonly UpDownCounter<long> ExecutionStatus =
-        Meter.CreateUpDownCounter<long>(ExecutionStatusMetricName, unit: "{executions}",
+        Meter.CreateUpDownCounter<long>(
+            ExecutionStatusMetricName,
+            unit: "{executions}",
             description: "The number of actively running tasks grouped by task, type and the current state.");
 
     /// <summary>
@@ -59,14 +68,19 @@ internal static class HangfireMetrics
     /// Follows OpenTelemetry workflow semantic conventions.
     /// </summary>
     public static readonly Counter<long> ExecutionErrors =
-        Meter.CreateCounter<long>(ExecutionErrorsMetricName, unit: "{error}",
+        Meter.CreateCounter<long>(
+            ExecutionErrorsMetricName,
+            unit: "{error}",
             description: "The number of errors encountered in task runs (eg. compile, test failures).");
 
     /// <summary>
-    /// Histogram for time tasks spend waiting in queue before execution.
-    /// Hangfire-specific metric (not part of standard workflow conventions).
+    /// Counter for the number of workflow instances which have been initiated.
+    /// Follows OpenTelemetry workflow semantic conventions.
+    /// In Hangfire, this tracks individual job completions. For batch workflows, this would track batch completion.
     /// </summary>
-    public static readonly Histogram<double> QueueLatency =
-        Meter.CreateHistogram<double>(QueueLatencyMetricName, unit: "s",
-            description: "Time tasks spend waiting in queue before execution starts.");
+    public static readonly Counter<long> WorkflowCount =
+        Meter.CreateCounter<long>(
+            WorkflowCountMetricName,
+            unit: "{workflows}",
+            description: "The number of workflow instances which have been initiated.");
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
index eba09572ee..6c6fd9ca45 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
@@ -19,10 +19,10 @@ public HangfireMetricsInstrumentation(HangfireInstrumentationOptions options)
         this.AddFilter(new HangfireMetricsStateFilter());
         this.AddFilter(new HangfireMetricsErrorFilterAttribute());
 
-        // Only register queue latency filter if enabled (requires DB call per job)
+        // Only register pending duration filter if enabled (requires DB call per job)
         if (options.RecordQueueLatency)
         {
-            this.AddFilter(new HangfireQueueLatencyFilterAttribute());
+            this.AddFilter(new HangfirePendingDurationFilterAttribute());
         }
     }
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
index 821c71810e..b696021075 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
@@ -21,16 +21,46 @@ public void OnPerforming(PerformingContext performingContext)
 
     public void OnPerformed(PerformedContext performedContext)
     {
-        var executionTags = HangfireTagBuilder.BuildExecutionTags(performedContext.BackgroundJob.Job, performedContext.Exception);
+        // Get recurring job ID if this job was triggered by a recurring job
+        string? recurringJobId = null;
+        try
+        {
+            recurringJobId = performedContext.Connection.GetJobParameter(
+                performedContext.BackgroundJob.Id,
+                "RecurringJobId");
+        }
+        catch
+        {
+            // If we can't get the recurring job ID, treat it as a non-recurring job
+        }
 
-        HangfireMetrics.ExecutionCount.Add(1, executionTags);
+        // Record execution count (without state attribute per semantic conventions)
+        var countTags = HangfireTagBuilder.BuildExecutionCountTags(
+            performedContext.BackgroundJob.Job,
+            performedContext.Exception);
 
+        HangfireMetrics.ExecutionCount.Add(1, countTags);
+
+        // Record execution duration (with state="executing" to differentiate from pending phase)
         if (performedContext.Items.TryGetValue(StopwatchKey, out var stopwatchObj) && stopwatchObj is Stopwatch stopwatch)
         {
             stopwatch.Stop();
             var duration = stopwatch.Elapsed.TotalSeconds;
 
-            HangfireMetrics.ExecutionDuration.Record(duration, executionTags);
+            var durationTags = HangfireTagBuilder.BuildExecutionTags(
+                performedContext.BackgroundJob.Job,
+                performedContext.Exception,
+                workflowState: HangfireTagBuilder.StateExecuting);
+
+            HangfireMetrics.ExecutionDuration.Record(duration, durationTags);
         }
+
+        // Record workflow-level metrics (includes trigger type)
+        var workflowTags = HangfireTagBuilder.BuildWorkflowTags(
+            performedContext.BackgroundJob.Job,
+            performedContext.Exception,
+            recurringJobId);
+
+        HangfireMetrics.WorkflowCount.Add(1, workflowTags);
     }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index 2576c7ee33..e2f6ae4f7c 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -21,12 +21,10 @@ public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction tran
         }
 
         var errorType = GetErrorTypeFromNewState(context.NewState);
-        var recurringJobId = GetRecurringJobId(context);
         var tags = HangfireTagBuilder.BuildStateTags(
             context.BackgroundJob.Job,
             workflowState,
-            errorType,
-            recurringJobId);
+            errorType);
 
         HangfireMetrics.ExecutionStatus.Add(1, tags);
     }
@@ -40,12 +38,10 @@ public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction tr
         }
 
         var errorType = GetErrorTypeFromOldState(context);
-        var recurringJobId = GetRecurringJobId(context);
         var tags = HangfireTagBuilder.BuildStateTags(
             context.BackgroundJob.Job,
             workflowState,
-            errorType,
-            recurringJobId);
+            errorType);
 
         HangfireMetrics.ExecutionStatus.Add(-1, tags);
     }
@@ -91,17 +87,4 @@ public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction tr
 
         return null;
     }
-
-    private static string? GetRecurringJobId(ApplyStateContext context)
-    {
-        try
-        {
-            return context.Connection.GetJobParameter(context.BackgroundJob.Id, "RecurringJobId");
-        }
-        catch
-        {
-            // Parameter doesn't exist or couldn't be retrieved
-            return null;
-        }
-    }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireQueueLatencyFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
similarity index 67%
rename from src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireQueueLatencyFilterAttribute.cs
rename to src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
index 1833de18ba..282891657a 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireQueueLatencyFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
@@ -9,13 +9,14 @@
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
 /// <summary>
-/// Hangfire filter that records queue latency metrics.
+/// Hangfire filter that records workflow.execution.duration metric for the pending state.
 /// </summary>
 /// <remarks>
 /// This filter captures the EnqueuedAt timestamp when a job enters the Enqueued state
-/// and calculates queue latency when the job starts executing.
+/// and records workflow.execution.duration{state="pending"} when the job starts executing.
+/// This represents the time a job spent waiting in the queue before execution started.
 /// </remarks>
-internal sealed class HangfireQueueLatencyFilterAttribute : JobFilterAttribute, IServerFilter, IElectStateFilter
+internal sealed class HangfirePendingDurationFilterAttribute : JobFilterAttribute, IServerFilter, IElectStateFilter
 {
     private const string EnqueuedAtParameter = "OpenTelemetry.EnqueuedAt";
 
@@ -52,10 +53,14 @@ public void OnPerforming(PerformingContext performingContext)
             if (!string.IsNullOrEmpty(enqueuedAtStr))
             {
                 var enqueuedAt = JobHelper.DeserializeDateTime(enqueuedAtStr);
-                var queueLatency = (DateTime.UtcNow - enqueuedAt).TotalSeconds;
+                var pendingDuration = (DateTime.UtcNow - enqueuedAt).TotalSeconds;
 
-                var tags = HangfireTagBuilder.BuildCommonTags(performingContext.BackgroundJob.Job);
-                HangfireMetrics.QueueLatency.Record(queueLatency, tags);
+                // Record workflow.execution.duration with state="pending"
+                var tags = HangfireTagBuilder.BuildExecutionTags(
+                    performingContext.BackgroundJob.Job,
+                    exception: null,
+                    workflowState: HangfireTagBuilder.StatePending);
+                HangfireMetrics.ExecutionDuration.Record(pendingDuration, tags);
             }
         }
         catch
@@ -66,6 +71,6 @@ public void OnPerforming(PerformingContext performingContext)
 
     public void OnPerformed(PerformedContext performedContext)
     {
-        // No-op: This filter only handles queue latency in OnPerforming
+        // No-op: This filter only handles pending state duration in OnPerforming
     }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index 504020a3b8..d398255f92 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -17,7 +17,9 @@ internal static class HangfireTagBuilder
     // Tag name constants following OpenTelemetry workflow semantic conventions
     // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md
     internal const string TagWorkflowTaskName = "workflow.task.name";
+    internal const string TagWorkflowDefinitionName = "workflow.definition.name";
     internal const string TagWorkflowExecutionOutcome = "workflow.execution.outcome";
+    internal const string TagWorkflowOutcome = "workflow.outcome";
     internal const string TagWorkflowExecutionState = "workflow.execution.state";
     internal const string TagWorkflowPlatformName = "workflow.platform.name";
     internal const string TagWorkflowTriggerType = "workflow.trigger.type";
@@ -58,22 +60,21 @@ public static TagList BuildCommonTags(Job job)
 
     /// <summary>
     /// Creates a tag list representing workflow execution state transitions.
-    /// Includes required workflow.task.name, workflow.execution.state, and workflow.trigger.type tags,
+    /// Includes required workflow.task.name and workflow.execution.state tags,
     /// recommended workflow.platform.name, and conditionally required error.type.
+    /// Note: workflow.trigger.type is NOT included as it belongs to workflow-level metrics only.
     /// </summary>
     /// <param name="job">The Hangfire job.</param>
     /// <param name="workflowState">The workflow state value.</param>
     /// <param name="errorType">Optional error type to annotate failure states.</param>
-    /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
     /// <returns>Tag list suitable for workflow.execution.status metric.</returns>
-    public static TagList BuildStateTags(Job job, string workflowState, string? errorType, string? recurringJobId)
+    public static TagList BuildStateTags(Job job, string workflowState, string? errorType)
     {
         var tags = new TagList
         {
             GetTaskName(job),
             GetPlatformName(),
             GetState(workflowState),
-            GetTriggerType(recurringJobId),
         };
 
         if (!string.IsNullOrEmpty(errorType))
@@ -115,20 +116,23 @@ public static TagList BuildStateTags(Job job, string workflowState, string? erro
 
     /// <summary>
     /// Creates a tag list with execution result tags following workflow semantic conventions.
-    /// Includes required attributes (workflow.task.name, workflow.execution.outcome),
+    /// Includes required attributes (workflow.task.name, workflow.execution.outcome, workflow.execution.state),
     /// recommended attributes (workflow.platform.name),
-    /// conditionally required attributes (error.type if failed)
+    /// conditionally required attributes (error.type if failed).
+    /// Note: workflow.trigger.type is NOT included as it belongs to workflow-level metrics only.
     /// </summary>
     /// <param name="job">The Hangfire job.</param>
     /// <param name="exception">The exception, if any occurred.</param>
+    /// <param name="workflowState">The workflow state value (typically "executing" for execution duration).</param>
     /// <returns>Tag list with execution result tags.</returns>
-    public static TagList BuildExecutionTags(Job job, Exception? exception)
+    public static TagList BuildExecutionTags(Job job, Exception? exception, string workflowState)
     {
         var tags = new TagList
         {
             GetTaskName(job),
             GetPlatformName(),
-            GetOutcome(exception),
+            GetExecutionOutcome(exception),
+            GetState(workflowState),
         };
 
         // Conditionally Required: error.type (if and only if the task run failed)
@@ -140,6 +144,64 @@ public static TagList BuildExecutionTags(Job job, Exception? exception)
         return tags;
     }
 
+    /// <summary>
+    /// Creates a tag list for workflow.execution.count metric following workflow semantic conventions.
+    /// Includes required attributes (workflow.task.name, workflow.execution.outcome),
+    /// recommended attributes (workflow.platform.name),
+    /// conditionally required attributes (error.type if failed).
+    /// Note: Does NOT include workflow.execution.state as it's not specified in semantic conventions for count metric.
+    /// </summary>
+    /// <param name="job">The Hangfire job.</param>
+    /// <param name="exception">The exception, if any occurred.</param>
+    /// <returns>Tag list suitable for workflow.execution.count metric.</returns>
+    public static TagList BuildExecutionCountTags(Job job, Exception? exception)
+    {
+        var tags = new TagList
+        {
+            GetTaskName(job),
+            GetPlatformName(),
+            GetExecutionOutcome(exception),
+        };
+
+        // Conditionally Required: error.type (if and only if the task run failed)
+        if (exception is not null)
+        {
+            tags.Add(GetErrorType(exception));
+        }
+
+        return tags;
+    }
+
+    /// <summary>
+    /// Creates a tag list for workflow-level metrics following workflow semantic conventions.
+    /// Includes required attributes (workflow.definition.name, workflow.outcome, workflow.trigger.type),
+    /// recommended attributes (workflow.platform.name),
+    /// conditionally required attributes (error.type if failed).
+    /// Used for workflow.count and other workflow-level (not execution-level) metrics.
+    /// </summary>
+    /// <param name="job">The Hangfire job.</param>
+    /// <param name="exception">The exception, if any occurred.</param>
+    /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
+    /// <returns>Tag list suitable for workflow.count metric.</returns>
+    public static TagList BuildWorkflowTags(Job job, Exception? exception, string? recurringJobId)
+    {
+        var tags = new TagList
+        {
+            GetDefinitionName(job),
+            GetPlatformName(),
+            GetWorkflowOutcome(exception),
+            GetTriggerType(recurringJobId),
+        };
+
+        // Conditionally Required: error.type (if and only if the workflow execution failed)
+        if (exception is not null)
+        {
+            tags.Add(GetErrorType(exception));
+        }
+
+        return tags;
+    }
+
     /// <summary>
     /// Creates a tag list for workflow.execution.errors metric following workflow semantic conventions.
     /// Includes required attributes (error.type, workflow.task.name),
@@ -164,9 +226,15 @@ public static TagList BuildErrorTags(Job job, Exception exception)
     private static KeyValuePair<string, object?> GetTaskName(Job job) =>
         new(TagWorkflowTaskName, job.ToString() ?? "unknown");
 
-    private static KeyValuePair<string, object?> GetOutcome(Exception? exception) =>
+    private static KeyValuePair<string, object?> GetDefinitionName(Job job) =>
+        new(TagWorkflowDefinitionName, job.ToString() ?? "unknown");
+
+    private static KeyValuePair<string, object?> GetExecutionOutcome(Exception? exception) =>
         new(TagWorkflowExecutionOutcome, exception is null ? OutcomeSuccess : OutcomeFailure);
 
+    private static KeyValuePair<string, object?> GetWorkflowOutcome(Exception? exception) =>
+        new(TagWorkflowOutcome, exception is null ? OutcomeSuccess : OutcomeFailure);
+
     private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId)
     {
         // Check if job was triggered by a recurring job (cron)
@@ -191,9 +259,9 @@ public static TagList BuildErrorTags(Job job, Exception exception)
     {
         var loggedException = exception;
 
-        if (loggedException is JobPerformanceException pe)
+        if (loggedException is JobPerformanceException { InnerException: not null } pe)
         {
-            loggedException = pe.InnerException;
+            loggedException = pe.InnerException!;
         }
 
         return new KeyValuePair<string, object?>(TagErrorType, loggedException.GetType().FullName ?? loggedException.GetType().Name);
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 1307428e8b..8983db6587 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -214,8 +214,9 @@ and metrics behavior.
 
 #### RecordQueueLatency
 
-By default, the instrumentation records only execution metrics. To also track how long
-jobs spend waiting in the queue before execution, enable the `RecordQueueLatency` option:
+By default, the instrumentation records only the execution phase duration (time spent
+actually running the job). To also track the pending phase duration (time spent waiting
+in the queue before execution), enable the `RecordQueueLatency` option:
 
 ```csharp
 var meterProvider = Sdk.CreateMeterProviderBuilder()
@@ -227,6 +228,10 @@ var meterProvider = Sdk.CreateMeterProviderBuilder()
     .Build();
 ```
 
+When enabled, `workflow.execution.duration` is recorded with `workflow.execution.state="pending"`
+representing queue wait time, in addition to `workflow.execution.state="executing"` for actual
+execution time.
+
 > [!WARNING]
 > Enabling `RecordQueueLatency` requires an additional database query per job execution
 > to retrieve the enqueue timestamp. In high-throughput scenarios, this may impact
@@ -244,6 +249,10 @@ The number of task executions which have been initiated.
 |----------------|-----------------|------------|
 | `{executions}` | Counter         | `Int64`    |
 
+> [!NOTE]
+> This metric does NOT include the `workflow.execution.state` attribute, as state differentiation
+> is not needed for counting completed executions.
+
 **Attributes:**
 
 | Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
@@ -257,15 +266,31 @@ The number of task executions which have been initiated.
 
 #### workflow.execution.duration
 
-Duration of an execution grouped by task and result.
+Duration of an execution grouped by task, state, and result. Records duration for different
+execution phases:
+- **state=pending**: Time spent waiting in queue (only when `RecordQueueLatency` is enabled)
+- **state=executing**: Time spent in actual execution
 
 | Units | Instrument Type | Value Type |
 |-------|-----------------|------------|
 | `s`   | Histogram       | `Double`   |
 
+> [!NOTE]
+> The `workflow.execution.state` attribute is an extension to the current semantic conventions
+> to support measuring different execution phases (pending vs executing). This attribute is
+> being proposed for inclusion in the official semantic conventions.
+
 **Attributes:**
 
-Uses the same attributes as `workflow.execution.count`.
+| Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
+|-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
+| `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`   |
+| `workflow.execution.outcome`  | string | The outcome of executing the task             | Required                 | `success`, `failure`    |
+| `workflow.execution.state`    | string | The execution phase being measured            | Required                 | `pending`, `executing`  |
+| `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
+
+¹ Required if and only if the task execution failed.
 
 #### workflow.execution.status
 
@@ -285,7 +310,6 @@ The number of actively running tasks grouped by task and the current state.
 |-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------------------------|
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`                     |
 | `workflow.execution.state`    | string | Current state of the execution                | Required                 | `pending`, `executing`, `completed`       |
-| `workflow.trigger.type`       | string | Type of trigger that initiated the execution  | Required                 | `api`, `cron`                             |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`                                |
 | `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name                       |
 
@@ -317,37 +341,40 @@ The number of errors encountered in task executions.
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required          | e.g., `MyJob.Execute`   |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended       | `hangfire`              |
 
-#### hangfire.queue.latency
+#### workflow.count
 
-Time tasks spend waiting in queue before execution starts. This is a Hangfire-specific
-metric not part of the standard workflow conventions.
+The number of workflow instances which have been initiated. In Hangfire, this tracks
+individual job completions.
 
-| Units | Instrument Type | Value Type |
-|-------|-----------------|------------|
-| `s`   | Histogram       | `Double`   |
-
-> [!NOTE]
-> This metric is only recorded when `RecordQueueLatency` option is enabled.
+| Units          | Instrument Type | Value Type |
+|----------------|-----------------|------------|
+| `{workflows}`  | Counter         | `Int64`    |
 
 **Attributes:**
 
-| Attribute                     | Type   | Description                                   | Requirement Level | Values                  |
-|-------------------------------|--------|-----------------------------------------------|-------------------|-------------------------|
-| `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required          | e.g., `MyJob.Execute`   |
-| `workflow.platform.name`      | string | The workflow platform being used              | Recommended       | `hangfire`              |
+| Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
+|-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
+| `workflow.definition.name`    | string | Name of the workflow (Hangfire job method)    | Required                 | e.g., `MyJob.Execute`   |
+| `workflow.outcome`            | string | The outcome of the workflow                   | Required                 | `success`, `failure`    |
+| `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`           |
+| `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
+
+¹ Required if and only if the workflow execution failed.
 
 ### Semantic Conventions
 
 This instrumentation follows the OpenTelemetry semantic conventions for workflows:
 
 - **workflow.platform.name**: Always set to `"hangfire"`
-- **workflow.task.name**: Derived from the Hangfire job method (e.g., `ClassName.MethodName`)
+- **workflow.task.name** / **workflow.definition.name**: Derived from the Hangfire job method (e.g., `ClassName.MethodName`)
 - **workflow.trigger.type**: Set to `"cron"` for recurring jobs, `"api"` for fire-and-forget,
-  scheduled, and continuation jobs
-- **workflow.execution.outcome**: Set to `"success"` when jobs complete without errors,
+  scheduled, and continuation jobs. Only included on workflow-level metrics (`workflow.count`),
+  not on execution-level metrics (`workflow.execution.*`)
+- **workflow.execution.outcome** / **workflow.outcome**: Set to `"success"` when jobs complete without errors,
   `"failure"` when an exception is thrown
 - **workflow.execution.state**: Maps Hangfire states to semantic convention states
-  (see table above)
+  (see table above). Also used to distinguish between pending (queue wait) and executing (actual execution) phases in duration metrics
 - **error.type**: Set to the full type name of the exception when a job fails
 
 ## References
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index 172e759257..dc60ad21be 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -128,7 +128,7 @@ public async Task Should_Record_ExecutionDuration_Metric_With_ErrorType_For_Fail
     }
 
     [Fact]
-    public async Task Should_Record_QueueLatency_Metric_When_Enabled()
+    public async Task Should_Record_PendingDuration_Metric_When_RecordQueueLatency_Enabled()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -146,24 +146,28 @@ public async Task Should_Record_QueueLatency_Metric_When_Enabled()
 
         meterProvider.ForceFlush();
 
-        // Assert
-        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
-        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
-        Assert.Equal("s", queueLatencyMetric!.Unit);
-        Assert.Equal(MetricType.Histogram, queueLatencyMetric.MetricType);
+        // Assert - Should record workflow.execution.duration with state="pending"
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
+        Assert.Equal("s", durationMetric!.Unit);
+        Assert.Equal(MetricType.Histogram, durationMetric.MetricType);
 
-        var metricPoints = queueLatencyMetric.ToMetricPointList();
-        var metricPoint = metricPoints.First();
+        var metricPoints = durationMetric.ToMetricPointList();
 
-        var count = metricPoint.GetHistogramCount();
-        var sum = metricPoint.GetHistogramSum();
+        // Find the pending state metric point
+        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        Assert.NotNull(pendingPoint);
 
-        Assert.True(count >= 1, $"Expected histogram count >= 1, got {count}");
-        Assert.True(sum >= 0, $"Expected queue latency sum >= 0, got {sum}");
+        var count = pendingPoint.Value.GetHistogramCount();
+        var sum = pendingPoint.Value.GetHistogramSum();
+
+        Assert.True(count >= 1, $"Expected histogram count >= 1 for pending state, got {count}");
+        Assert.True(sum >= 0, $"Expected histogram sum >= 0 for pending state, got {sum}");
 
         // Validate tags
-        AssertUtils.AssertHasTag(metricPoint, "workflow.task.name");
-        AssertUtils.AssertHasTag(metricPoint, "workflow.platform.name");
+        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowTaskName);
+        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
     }
 
     [Fact]
@@ -195,7 +199,9 @@ public async Task Should_Record_ExecutionStatus_States_For_Successful_Job()
             AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowTaskName);
             AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowPlatformName);
             AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowExecutionState);
-            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowTriggerType);
+
+            // Note: workflow.trigger.type should NOT be on execution-level metrics per semantic conventions
+            AssertUtils.AssertHasNoTag(point, HangfireTagBuilder.TagWorkflowTriggerType);
         }
 
         // Verify state transitions balance out to final state
@@ -212,7 +218,9 @@ public async Task Should_Record_ExecutionStatus_States_For_Successful_Job()
         Assert.NotNull(completedPoint);
 
         AssertUtils.AssertHasNoTag(completedPoint.Value, HangfireTagBuilder.TagErrorType);
-        AssertUtils.AssertHasTagValue(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeApi);
+
+        // Note: trigger.type should NOT be on execution-level metrics per semantic conventions
+        AssertUtils.AssertHasNoTag(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType);
     }
 
     [Fact]
@@ -254,8 +262,8 @@ public async Task Should_Record_ExecutionStatus_ErrorType_For_Failed_Job()
         // Verify error type is present and contains exception information
         AssertUtils.AssertTagContains(completedPoint.Value, HangfireTagBuilder.TagErrorType, "Exception");
 
-        // Verify trigger type
-        AssertUtils.AssertHasTagValue(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeApi);
+        // Note: trigger.type should NOT be on execution-level metrics per semantic conventions
+        AssertUtils.AssertHasNoTag(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType);
     }
 
     [Fact]
@@ -286,7 +294,7 @@ public async Task Should_Record_All_Metrics_For_Multiple_Jobs()
         exportedItems.GetMetric(HangfireMetrics.ExecutionCountMetricName);
         exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
         exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
-        exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
+        exportedItems.GetMetric(HangfireMetrics.WorkflowCountMetricName);
 
         // Verify execution.count has at least 3 executions
         var executionCountMetric = exportedItems.First(m => m.Name == HangfireMetrics.ExecutionCountMetricName);
@@ -333,7 +341,7 @@ public async Task Should_Track_Success_And_Failure_Outcomes_Separately()
     }
 
     [Fact]
-    public async Task Should_Record_TriggerType_Cron_For_Recurring_Jobs()
+    public async Task Should_Record_TriggerType_Cron_For_Recurring_Jobs_On_Workflow_Metric()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -350,18 +358,18 @@ public async Task Should_Record_TriggerType_Cron_For_Recurring_Jobs()
 
         meterProvider.ForceFlush();
 
-        // Assert - Check execution status metric has cron trigger type
-        var statusMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
-        AssertUtils.AssertHasMetricPoints(statusMetric);
-        var metricPoints = statusMetric!.ToMetricPointList();
+        // Assert - Check workflow.count metric has cron trigger type (NOT execution-level metrics)
+        var workflowCountMetric = exportedItems.GetMetric(HangfireMetrics.WorkflowCountMetricName);
+        AssertUtils.AssertHasMetricPoints(workflowCountMetric);
+        var metricPoints = workflowCountMetric!.ToMetricPointList();
 
-        // Find completed state metric point
-        var completedPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted);
+        // Find the workflow.count metric point
+        var workflowPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeCron);
 
-        Assert.NotNull(completedPoint);
+        Assert.NotNull(workflowPoint);
 
-        // Verify trigger type is 'cron' for recurring jobs
-        AssertUtils.AssertHasTagValue(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeCron);
+        // Verify trigger type is 'cron' for recurring jobs on workflow-level metric
+        AssertUtils.AssertHasTagValue(workflowPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeCron);
 
         // Cleanup
         RecurringJob.RemoveIfExists("test-recurring-job");
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
index 8d7a2c0eb1..698970e54f 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
@@ -20,7 +20,7 @@ public HangfireQueueLatencyTests(HangfireFixture hangfireFixture)
     }
 
     [Fact]
-    public async Task Should_NOT_Record_QueueLatency_Metric_By_Default()
+    public async Task Should_NOT_Record_PendingDuration_By_Default()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -35,13 +35,25 @@ public async Task Should_NOT_Record_QueueLatency_Metric_By_Default()
 
         meterProvider.ForceFlush();
 
-        // Assert - Queue latency metric should NOT be present
-        var queueLatencyMetric = exportedItems.FirstOrDefault(m => m.Name == HangfireMetrics.QueueLatencyMetricName);
-        Assert.Null(queueLatencyMetric);
+        // Assert - workflow.execution.duration with state="pending" should NOT be present
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+
+        // Duration metric will exist (for state="executing"), but NOT for state="pending"
+        Assert.NotNull(durationMetric);
+        var metricPoints = durationMetric.ToMetricPointList();
+
+        // Ensure NO pending state metric point exists
+        var pendingPoints = metricPoints.Where(mp =>
+        {
+            var stateValue = mp.GetTagValue(HangfireTagBuilder.TagWorkflowExecutionState);
+            return stateValue != null && stateValue.Equals(HangfireTagBuilder.StatePending);
+        }).ToList();
+
+        Assert.Empty(pendingPoints);
     }
 
     [Fact]
-    public async Task Should_Record_QueueLatency_Metric_When_Enabled()
+    public async Task Should_Record_PendingDuration_When_RecordQueueLatency_Enabled()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -59,28 +71,33 @@ public async Task Should_Record_QueueLatency_Metric_When_Enabled()
 
         meterProvider.ForceFlush();
 
-        // Assert - Queue latency metric should be present
-        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
-        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
-        Assert.Equal("s", queueLatencyMetric!.Unit);
-        Assert.Equal(MetricType.Histogram, queueLatencyMetric.MetricType);
+        // Assert - workflow.execution.duration with state="pending" should be present
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
+        Assert.Equal("s", durationMetric!.Unit);
+        Assert.Equal(MetricType.Histogram, durationMetric.MetricType);
+
+        var metricPoints = durationMetric.ToMetricPointList();
 
-        var metricPoints = queueLatencyMetric.ToMetricPointList();
-        var metricPoint = metricPoints.First();
+        // Find the pending state metric point
+        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        Assert.NotNull(pendingPoint);
 
-        var count = metricPoint.GetHistogramCount();
-        var sum = metricPoint.GetHistogramSum();
+        var count = pendingPoint.Value.GetHistogramCount();
+        var sum = pendingPoint.Value.GetHistogramSum();
 
-        Assert.True(count >= 1, $"Expected histogram count >= 1, got {count}");
-        Assert.True(sum >= 0, $"Expected queue latency sum >= 0, got {sum}");
+        Assert.True(count >= 1, $"Expected histogram count >= 1 for pending state, got {count}");
+        Assert.True(sum >= 0, $"Expected histogram sum >= 0 for pending state, got {sum}");
 
         // Validate tags
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
+        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowTaskName);
+        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
     }
 
     [Fact]
-    public async Task Should_NOT_Record_QueueLatency_Metric_When_Explicitly_Disabled()
+    public async Task Should_NOT_Record_PendingDuration_When_Explicitly_Disabled()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -98,13 +115,25 @@ public async Task Should_NOT_Record_QueueLatency_Metric_When_Explicitly_Disabled
 
         meterProvider.ForceFlush();
 
-        // Assert - Queue latency metric should NOT be present
-        var queueLatencyMetric = exportedItems.FirstOrDefault(m => m.Name == HangfireMetrics.QueueLatencyMetricName);
-        Assert.Null(queueLatencyMetric);
+        // Assert - workflow.execution.duration with state="pending" should NOT be present
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+
+        // Duration metric will exist (for state="executing"), but NOT for state="pending"
+        Assert.NotNull(durationMetric);
+        var metricPoints = durationMetric.ToMetricPointList();
+
+        // Ensure NO pending state metric point exists
+        var pendingPoints = metricPoints.Where(mp =>
+        {
+            var stateValue = mp.GetTagValue(HangfireTagBuilder.TagWorkflowExecutionState);
+            return stateValue != null && stateValue.Equals(HangfireTagBuilder.StatePending);
+        }).ToList();
+
+        Assert.Empty(pendingPoints);
     }
 
     [Fact]
-    public async Task Should_Record_Accurate_QueueLatency_For_Retried_Job()
+    public async Task Should_Record_Both_Pending_And_Executing_Duration_When_Enabled()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -116,37 +145,69 @@ public async Task Should_Record_Accurate_QueueLatency_For_Retried_Job()
             .AddInMemoryExporter(exportedItems)
             .Build();
 
-        // Act - Create a job that fails first, then gets retried
-        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
         await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
-        // Clear metrics from first execution
-        exportedItems.Clear();
+        meterProvider.ForceFlush();
+
+        // Assert - Both pending and executing durations should be recorded
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
+
+        var metricPoints = durationMetric!.ToMetricPointList();
 
-        // Manually requeue the job (simulating retry)
-        BackgroundJob.Requeue(jobId);
+        // Verify pending state duration
+        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        Assert.NotNull(pendingPoint);
+        Assert.True(pendingPoint.Value.GetHistogramCount() >= 1);
+
+        // Verify executing state duration
+        var executingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting);
+        Assert.NotNull(executingPoint);
+        Assert.True(executingPoint.Value.GetHistogramCount() >= 1);
+    }
+
+    [Fact]
+    public async Task Should_Record_PendingDuration_For_Failed_Job()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.RecordQueueLatency = true;
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.ThrowException());
         await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
 
         meterProvider.ForceFlush();
 
-        // Assert - Queue latency should reflect time since re-enqueue, not original creation
-        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
-        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
+        // Assert - Pending duration should be recorded even for failed jobs
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
 
-        var metricPoints = queueLatencyMetric!.ToMetricPointList();
-        if (metricPoints.Count != 0)
-        {
-            var metricPoint = metricPoints.First();
-            var sum = metricPoint.GetHistogramSum();
+        var metricPoints = durationMetric!.ToMetricPointList();
 
-            // Queue latency should be small (< 10 seconds) since we just re-enqueued
-            // If it used CreatedAt, it would be much larger
-            Assert.True(sum < 10, $"Expected queue latency < 10 seconds for retry, got {sum}");
-        }
+        // Find pending state metric point (should have success outcome since pending phase succeeded)
+        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        Assert.NotNull(pendingPoint);
+
+        // Pending phase should be successful (job started executing)
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+
+        // Executing phase should have failure outcome
+        var executingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting);
+        Assert.NotNull(executingPoint);
+        AssertUtils.AssertHasTagValue(executingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeFailure);
     }
 
     [Fact]
-    public async Task Should_Record_QueueLatency_For_Multiple_Jobs()
+    public async Task Should_Record_PendingDuration_For_Multiple_Jobs()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -169,22 +230,22 @@ public async Task Should_Record_QueueLatency_For_Multiple_Jobs()
 
         meterProvider.ForceFlush();
 
-        // Assert - Queue latency metric should have multiple data points
-        var queueLatencyMetric = exportedItems.GetMetric(HangfireMetrics.QueueLatencyMetricName);
-        AssertUtils.AssertHasMetricPoints(queueLatencyMetric);
+        // Assert - Pending duration should be recorded for all jobs
+        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        AssertUtils.AssertHasMetricPoints(durationMetric);
 
-        var metricPoints = queueLatencyMetric!.ToMetricPointList();
-        Assert.NotEmpty(metricPoints);
+        var metricPoints = durationMetric!.ToMetricPointList();
 
-        // At least one metric point should exist (could be aggregated)
-        var metricPoint = metricPoints.First();
-        var count = metricPoint.GetHistogramCount();
+        // Find pending state metric point
+        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        Assert.NotNull(pendingPoint);
 
-        Assert.True(count >= 3, $"Expected at least 3 queue latency measurements, got {count}");
+        var count = pendingPoint.Value.GetHistogramCount();
+        Assert.True(count >= 3, $"Expected at least 3 pending duration measurements, got {count}");
     }
 
     [Fact]
-    public void Should_NOT_Register_QueueLatencyFilter_When_Disabled()
+    public void Should_NOT_Register_PendingDurationFilter_When_Disabled()
     {
         // Arrange
         var options = new Trace.HangfireInstrumentationOptions
@@ -195,16 +256,14 @@ public void Should_NOT_Register_QueueLatencyFilter_When_Disabled()
         // Act
         using var instrumentation = new Implementation.HangfireMetricsInstrumentation(options);
 
-        var finalFilterCount = GlobalJobFilters.Filters.Count;
-
-        // Verify no HangfireQueueLatencyFilterAttribute is registered
-        var queueLatencyFilterExists = GlobalJobFilters.Filters
-            .Any(f => f.Instance is Implementation.HangfireQueueLatencyFilterAttribute);
-        Assert.False(queueLatencyFilterExists);
+        // Verify no HangfirePendingDurationFilterAttribute is registered
+        var pendingDurationFilterExists = GlobalJobFilters.Filters
+            .Any(f => f.Instance is Implementation.HangfirePendingDurationFilterAttribute);
+        Assert.False(pendingDurationFilterExists);
     }
 
     [Fact]
-    public void Should_Register_QueueLatencyFilter_When_Enabled()
+    public void Should_Register_PendingDurationFilter_When_Enabled()
     {
         // Arrange
         var options = new Trace.HangfireInstrumentationOptions
@@ -215,11 +274,9 @@ public void Should_Register_QueueLatencyFilter_When_Enabled()
         // Act
         using var instrumentation = new Implementation.HangfireMetricsInstrumentation(options);
 
-        var finalFilterCount = GlobalJobFilters.Filters.Count;
-
-        // Verify HangfireQueueLatencyFilterAttribute IS registered
-        var queueLatencyFilterExists = GlobalJobFilters.Filters
-            .Any(f => f.Instance is Implementation.HangfireQueueLatencyFilterAttribute);
-        Assert.True(queueLatencyFilterExists);
+        // Verify HangfirePendingDurationFilterAttribute IS registered
+        var pendingDurationFilterExists = GlobalJobFilters.Filters
+            .Any(f => f.Instance is Implementation.HangfirePendingDurationFilterAttribute);
+        Assert.True(pendingDurationFilterExists);
     }
 }

From d43ee2cdd3a85b4031c065f7d5802dc71b3326be Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Wed, 22 Oct 2025 18:38:45 -0400
Subject: [PATCH 03/48] Configure metrics in
 HangfireMetricsInstrumentationOptions class, add DisplayNameFunc option

---
 .../.publicApi/PublicAPI.Unshipped.txt        | 12 ++++---
 .../HangfireInstrumentationOptions.cs         | 12 -------
 .../HangfireMetricsInstrumentationOptions.cs  | 33 +++++++++++++++++
 .../HangfireMetricsErrorFilterAttribute.cs    | 13 ++++++-
 .../HangfireMetricsInstrumentation.cs         | 12 +++----
 .../HangfireMetricsJobFilterAttribute.cs      | 21 +++++++++--
 .../HangfireMetricsStateFilter.cs             | 16 +++++++--
 .../HangfirePendingDurationFilterAttribute.cs | 12 ++++++-
 .../Implementation/HangfireTagBuilder.cs      | 35 ++++++++++---------
 .../MeterProviderBuilderExtensions.cs         | 11 +++---
 .../README.md                                 | 24 +++++++++++--
 .../DependencyInjectionConfigTests.cs         |  1 +
 .../HangfireMetricsTests.cs                   | 28 +++++++++++++++
 .../HangfireQueueLatencyTests.cs              |  4 +--
 14 files changed, 178 insertions(+), 56 deletions(-)
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt b/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
index e1ffb99341..275b190168 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
@@ -7,12 +7,16 @@ OpenTelemetry.Trace.HangfireInstrumentationOptions.Filter.set -> void
 OpenTelemetry.Trace.HangfireInstrumentationOptions.HangfireInstrumentationOptions() -> void
 OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordException.get -> bool
 OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordException.set -> void
-OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordQueueLatency.get -> bool
-OpenTelemetry.Trace.HangfireInstrumentationOptions.RecordQueueLatency.set -> void
 OpenTelemetry.Trace.TracerProviderBuilderExtensions
 static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder) -> OpenTelemetry.Metrics.MeterProviderBuilder!
-static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
-static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
+static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
+static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, System.Action<OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
+OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions
+OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.DisplayNameFunc.get -> System.Func<Hangfire.BackgroundJob!, string!>!
+OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.DisplayNameFunc.set -> void
+OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.HangfireMetricsInstrumentationOptions() -> void
+OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.RecordQueueLatency.get -> bool
+OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.RecordQueueLatency.set -> void
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder) -> OpenTelemetry.Trace.TracerProviderBuilder!
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Trace.TracerProviderBuilder!
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder, System.Action<OpenTelemetry.Trace.HangfireInstrumentationOptions!>? configure) -> OpenTelemetry.Trace.TracerProviderBuilder!
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
index e50e4f6251..467fe880b6 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireInstrumentationOptions.cs
@@ -45,16 +45,4 @@ public class HangfireInstrumentationOptions
     /// </list>
     /// </remarks>
     public Func<BackgroundJob, bool>? Filter { get; set; }
-
-    /// <summary>
-    /// Gets or sets a value indicating whether to record the pending state duration in metrics.
-    /// </summary>
-    /// <remarks>
-    /// When enabled, records workflow.execution.duration with state="pending", representing
-    /// the time jobs spend waiting in the queue before execution starts.
-    /// This requires an additional database call per job execution to retrieve the enqueue timestamp.
-    /// Default is <see langword="false"/> to avoid performance impact in high-throughput scenarios.
-    /// When disabled, only execution duration (state="executing") is recorded.
-    /// </remarks>
-    public bool RecordQueueLatency { get; set; }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
new file mode 100644
index 0000000000..941410c926
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
@@ -0,0 +1,33 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire;
+
+namespace OpenTelemetry.Metrics;
+
+/// <summary>
+/// Options for Hangfire metrics instrumentation.
+/// </summary>
+public sealed class HangfireMetricsInstrumentationOptions
+{
+    /// <summary>
+    /// Gets or sets a value indicating whether to record the pending state duration in metrics.
+    /// </summary>
+    /// <remarks>
+    /// When enabled, records workflow.execution.duration with state="pending", representing
+    /// the time jobs spend waiting in the queue before execution starts.
+    /// This requires an additional database call per job execution to retrieve the enqueue timestamp.
+    /// Default is <see langword="false"/> to avoid performance impact in high-throughput scenarios.
+    /// When disabled, only execution duration (state="executing") is recorded.
+    /// </remarks>
+    public bool RecordQueueLatency { get; set; }
+
+    /// <summary>
+    /// Gets or sets a delegate used to format the job name for metrics.
+    /// </summary>
+    /// <remarks>
+    /// Defaults to <c>backgroundJob.Job.ToString()</c>.
+    /// </remarks>
+    public Func<BackgroundJob, string> DisplayNameFunc { get; set; } =
+        backgroundJob => backgroundJob.Job?.ToString() ?? "unknown";
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
index 24f76b25be..5b67566382 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
@@ -3,6 +3,7 @@
 
 using Hangfire.Common;
 using Hangfire.Server;
+using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
@@ -12,6 +13,15 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal sealed class HangfireMetricsErrorFilterAttribute : JobFilterAttribute, IServerFilter
 {
+    private readonly HangfireMetricsInstrumentationOptions options;
+
+#pragma warning disable CA1019 // Define accessors for attribute arguments
+    public HangfireMetricsErrorFilterAttribute(HangfireMetricsInstrumentationOptions options)
+#pragma warning restore CA1019 // Define accessors for attribute arguments
+    {
+        this.options = options ?? throw new ArgumentNullException(nameof(options));
+    }
+
     public void OnPerforming(PerformingContext performingContext)
     {
     }
@@ -21,7 +31,8 @@ public void OnPerformed(PerformedContext performedContext)
         if (performedContext.Exception != null)
         {
             var errorTags = HangfireTagBuilder.BuildErrorTags(
-                performedContext.BackgroundJob.Job,
+                performedContext.BackgroundJob,
+                this.options.DisplayNameFunc,
                 performedContext.Exception);
 
             HangfireMetrics.ExecutionErrors.Add(1, errorTags);
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
index 6c6fd9ca45..87faaa2194 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using Hangfire;
-using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
@@ -13,16 +13,16 @@ internal sealed class HangfireMetricsInstrumentation : IDisposable
 {
     private readonly List<object> filters = new();
 
-    public HangfireMetricsInstrumentation(HangfireInstrumentationOptions options)
+    public HangfireMetricsInstrumentation(HangfireMetricsInstrumentationOptions options)
     {
-        this.AddFilter(new HangfireMetricsJobFilterAttribute());
-        this.AddFilter(new HangfireMetricsStateFilter());
-        this.AddFilter(new HangfireMetricsErrorFilterAttribute());
+        this.AddFilter(new HangfireMetricsJobFilterAttribute(options));
+        this.AddFilter(new HangfireMetricsStateFilter(options));
+        this.AddFilter(new HangfireMetricsErrorFilterAttribute(options));
 
         // Only register pending duration filter if enabled (requires DB call per job)
         if (options.RecordQueueLatency)
         {
-            this.AddFilter(new HangfirePendingDurationFilterAttribute());
+            this.AddFilter(new HangfirePendingDurationFilterAttribute(options));
         }
     }
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
index b696021075..cc7bdb8ce8 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using Hangfire.Common;
 using Hangfire.Server;
+using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
@@ -13,6 +14,14 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 internal sealed class HangfireMetricsJobFilterAttribute : JobFilterAttribute, IServerFilter
 {
     private const string StopwatchKey = "OpenTelemetry.Metrics.Stopwatch";
+    private readonly HangfireMetricsInstrumentationOptions options;
+
+#pragma warning disable CA1019 // Define accessors for attribute arguments
+    public HangfireMetricsJobFilterAttribute(HangfireMetricsInstrumentationOptions options)
+#pragma warning restore CA1019 // Define accessors for attribute arguments
+    {
+        this.options = options ?? throw new ArgumentNullException(nameof(options));
+    }
 
     public void OnPerforming(PerformingContext performingContext)
     {
@@ -34,9 +43,13 @@ public void OnPerformed(PerformedContext performedContext)
             // If we can't get the recurring job ID, treat it as a non-recurring job
         }
 
+        var backgroundJob = performedContext.BackgroundJob;
+        var displayNameFunc = this.options.DisplayNameFunc;
+
         // Record execution count (without state attribute per semantic conventions)
         var countTags = HangfireTagBuilder.BuildExecutionCountTags(
-            performedContext.BackgroundJob.Job,
+            backgroundJob,
+            displayNameFunc,
             performedContext.Exception);
 
         HangfireMetrics.ExecutionCount.Add(1, countTags);
@@ -48,7 +61,8 @@ public void OnPerformed(PerformedContext performedContext)
             var duration = stopwatch.Elapsed.TotalSeconds;
 
             var durationTags = HangfireTagBuilder.BuildExecutionTags(
-                performedContext.BackgroundJob.Job,
+                backgroundJob,
+                displayNameFunc,
                 performedContext.Exception,
                 workflowState: HangfireTagBuilder.StateExecuting);
 
@@ -57,7 +71,8 @@ public void OnPerformed(PerformedContext performedContext)
 
         // Record workflow-level metrics (includes trigger type)
         var workflowTags = HangfireTagBuilder.BuildWorkflowTags(
-            performedContext.BackgroundJob.Job,
+            backgroundJob,
+            displayNameFunc,
             performedContext.Exception,
             recurringJobId);
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index e2f6ae4f7c..0be33a86df 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -4,6 +4,7 @@
 using Hangfire.Common;
 using Hangfire.States;
 using Hangfire.Storage;
+using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
@@ -12,6 +13,15 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal sealed class HangfireMetricsStateFilter : JobFilterAttribute, IApplyStateFilter
 {
+    private readonly HangfireMetricsInstrumentationOptions options;
+
+#pragma warning disable CA1019 // Define accessors for attribute arguments
+    public HangfireMetricsStateFilter(HangfireMetricsInstrumentationOptions options)
+#pragma warning restore CA1019 // Define accessors for attribute arguments
+    {
+        this.options = options ?? throw new ArgumentNullException(nameof(options));
+    }
+
     public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
     {
         var workflowState = HangfireTagBuilder.MapWorkflowState(context.NewState.Name);
@@ -22,7 +32,8 @@ public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction tran
 
         var errorType = GetErrorTypeFromNewState(context.NewState);
         var tags = HangfireTagBuilder.BuildStateTags(
-            context.BackgroundJob.Job,
+            context.BackgroundJob,
+            this.options.DisplayNameFunc,
             workflowState,
             errorType);
 
@@ -39,7 +50,8 @@ public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction tr
 
         var errorType = GetErrorTypeFromOldState(context);
         var tags = HangfireTagBuilder.BuildStateTags(
-            context.BackgroundJob.Job,
+            context.BackgroundJob,
+            this.options.DisplayNameFunc,
             workflowState,
             errorType);
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
index 282891657a..3f4f7296b1 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
@@ -4,6 +4,7 @@
 using Hangfire.Common;
 using Hangfire.Server;
 using Hangfire.States;
+using OpenTelemetry.Metrics;
 using DateTime = System.DateTime;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
@@ -19,6 +20,14 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 internal sealed class HangfirePendingDurationFilterAttribute : JobFilterAttribute, IServerFilter, IElectStateFilter
 {
     private const string EnqueuedAtParameter = "OpenTelemetry.EnqueuedAt";
+    private readonly HangfireMetricsInstrumentationOptions options;
+
+#pragma warning disable CA1019 // Define accessors for attribute arguments
+    public HangfirePendingDurationFilterAttribute(HangfireMetricsInstrumentationOptions options)
+#pragma warning restore CA1019 // Define accessors for attribute arguments
+    {
+        this.options = options ?? throw new ArgumentNullException(nameof(options));
+    }
 
     public void OnStateElection(ElectStateContext context)
     {
@@ -57,7 +66,8 @@ public void OnPerforming(PerformingContext performingContext)
 
                 // Record workflow.execution.duration with state="pending"
                 var tags = HangfireTagBuilder.BuildExecutionTags(
-                    performingContext.BackgroundJob.Job,
+                    performingContext.BackgroundJob,
+                    this.options.DisplayNameFunc,
                     exception: null,
                     workflowState: HangfireTagBuilder.StatePending);
                 HangfireMetrics.ExecutionDuration.Record(pendingDuration, tags);
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index d398255f92..8e5281a8d6 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using System.Diagnostics;
-using Hangfire.Common;
+using Hangfire;
 using Hangfire.Server;
 using Hangfire.States;
 
@@ -48,11 +48,11 @@ internal static class HangfireTagBuilder
     /// </summary>
     /// <param name="job">The Hangfire job.</param>
     /// <returns>Tag list with common job tags.</returns>
-    public static TagList BuildCommonTags(Job job)
+    public static TagList BuildCommonTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc)
     {
         var tags = new TagList
         {
-            GetTaskName(job),
+            GetTaskName(backgroundJob, displayNameFunc),
             GetPlatformName(),
         };
         return tags;
@@ -68,11 +68,11 @@ public static TagList BuildCommonTags(Job job)
     /// <param name="workflowState">The workflow state value.</param>
     /// <param name="errorType">Optional error type to annotate failure states.</param>
     /// <returns>Tag list suitable for workflow.execution.status metric.</returns>
-    public static TagList BuildStateTags(Job job, string workflowState, string? errorType)
+    public static TagList BuildStateTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, string workflowState, string? errorType)
     {
         var tags = new TagList
         {
-            GetTaskName(job),
+            GetTaskName(backgroundJob, displayNameFunc),
             GetPlatformName(),
             GetState(workflowState),
         };
@@ -125,11 +125,11 @@ public static TagList BuildStateTags(Job job, string workflowState, string? erro
     /// <param name="exception">The exception, if any occurred.</param>
     /// <param name="workflowState">The workflow state value (typically "executing" for execution duration).</param>
     /// <returns>Tag list with execution result tags.</returns>
-    public static TagList BuildExecutionTags(Job job, Exception? exception, string workflowState)
+    public static TagList BuildExecutionTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, Exception? exception, string workflowState)
     {
         var tags = new TagList
         {
-            GetTaskName(job),
+            GetTaskName(backgroundJob, displayNameFunc),
             GetPlatformName(),
             GetExecutionOutcome(exception),
             GetState(workflowState),
@@ -154,11 +154,11 @@ public static TagList BuildExecutionTags(Job job, Exception? exception, string w
     /// <param name="job">The Hangfire job.</param>
     /// <param name="exception">The exception, if any occurred.</param>
     /// <returns>Tag list suitable for workflow.execution.count metric.</returns>
-    public static TagList BuildExecutionCountTags(Job job, Exception? exception)
+    public static TagList BuildExecutionCountTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, Exception? exception)
     {
         var tags = new TagList
         {
-            GetTaskName(job),
+            GetTaskName(backgroundJob, displayNameFunc),
             GetPlatformName(),
             GetExecutionOutcome(exception),
         };
@@ -183,11 +183,11 @@ public static TagList BuildExecutionCountTags(Job job, Exception? exception)
     /// <param name="exception">The exception, if any occurred.</param>
     /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
     /// <returns>Tag list suitable for workflow.count metric.</returns>
-    public static TagList BuildWorkflowTags(Job job, Exception? exception, string? recurringJobId)
+    public static TagList BuildWorkflowTags(BackgroundJob job, Func<BackgroundJob, string> displayNameFunc, Exception? exception, string? recurringJobId)
     {
         var tags = new TagList
         {
-            GetDefinitionName(job),
+            GetDefinitionName(job, displayNameFunc),
             GetPlatformName(),
             GetWorkflowOutcome(exception),
             GetTriggerType(recurringJobId),
@@ -210,12 +210,12 @@ public static TagList BuildWorkflowTags(Job job, Exception? exception, string? r
     /// <param name="job">The Hangfire job.</param>
     /// <param name="exception">The exception that occurred.</param>
     /// <returns>Tag list with error tags.</returns>
-    public static TagList BuildErrorTags(Job job, Exception exception)
+    public static TagList BuildErrorTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, Exception exception)
     {
         var tags = new TagList
         {
             GetErrorType(exception),
-            GetTaskName(job),
+            GetTaskName(backgroundJob, displayNameFunc),
             GetPlatformName(),
         };
 
@@ -223,11 +223,12 @@ public static TagList BuildErrorTags(Job job, Exception exception)
     }
 
     // Required workflow attributes
-    private static KeyValuePair<string, object?> GetTaskName(Job job) =>
-        new(TagWorkflowTaskName, job.ToString() ?? "unknown");
+    private static KeyValuePair<string, object?> GetTaskName(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc) =>
+        new(TagWorkflowTaskName, displayNameFunc(backgroundJob));
+
+    private static KeyValuePair<string, object?> GetDefinitionName(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc) =>
+        new(TagWorkflowDefinitionName, displayNameFunc(backgroundJob));
 
-    private static KeyValuePair<string, object?> GetDefinitionName(Job job) =>
-        new(TagWorkflowDefinitionName, job.ToString() ?? "unknown");
 
     private static KeyValuePair<string, object?> GetExecutionOutcome(Exception? exception) =>
         new(TagWorkflowExecutionOutcome, exception is null ? OutcomeSuccess : OutcomeFailure);
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs
index efb629a493..4ebf013f25 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/MeterProviderBuilderExtensions.cs
@@ -5,7 +5,6 @@
 using Microsoft.Extensions.Options;
 using OpenTelemetry.Instrumentation.Hangfire.Implementation;
 using OpenTelemetry.Internal;
-using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Metrics;
 
@@ -27,11 +26,11 @@ public static MeterProviderBuilder AddHangfireInstrumentation(
     /// Enables Hangfire metrics instrumentation.
     /// </summary>
     /// <param name="builder"><see cref="MeterProviderBuilder"/> being configured.</param>
-    /// <param name="configure">Callback action for configuring <see cref="HangfireInstrumentationOptions"/>.</param>
+    /// <param name="configure">Callback action for configuring <see cref="HangfireMetricsInstrumentationOptions"/>.</param>
     /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
     public static MeterProviderBuilder AddHangfireInstrumentation(
         this MeterProviderBuilder builder,
-        Action<HangfireInstrumentationOptions>? configure)
+        Action<HangfireMetricsInstrumentationOptions>? configure)
         => AddHangfireInstrumentation(builder, name: null, configure);
 
     /// <summary>
@@ -39,12 +38,12 @@ public static MeterProviderBuilder AddHangfireInstrumentation(
     /// </summary>
     /// <param name="builder"><see cref="MeterProviderBuilder"/> being configured.</param>
     /// <param name="name">Name which is used when retrieving options.</param>
-    /// <param name="configure"><see cref="HangfireInstrumentationOptions"/> configuration options.</param>
+    /// <param name="configure"><see cref="HangfireMetricsInstrumentationOptions"/> configuration options.</param>
     /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
     public static MeterProviderBuilder AddHangfireInstrumentation(
         this MeterProviderBuilder builder,
         string? name,
-        Action<HangfireInstrumentationOptions>? configure)
+        Action<HangfireMetricsInstrumentationOptions>? configure)
     {
         Guard.ThrowIfNull(builder);
 
@@ -59,7 +58,7 @@ public static MeterProviderBuilder AddHangfireInstrumentation(
 
         return builder.AddInstrumentation(sp =>
         {
-            var options = sp.GetRequiredService<IOptionsMonitor<HangfireInstrumentationOptions>>().Get(name);
+            var options = sp.GetRequiredService<IOptionsMonitor<HangfireMetricsInstrumentationOptions>>().Get(name);
             return new HangfireMetricsInstrumentation(options);
         });
     }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 8983db6587..91aed3e9e3 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -209,8 +209,8 @@ builder.Services.AddOpenTelemetry()
 
 ### Metrics Configuration
 
-The same `HangfireInstrumentationOptions` class is used to configure both tracing
-and metrics behavior.
+Metrics behavior is configured through the `HangfireMetricsInstrumentationOptions` class
+in the `OpenTelemetry.Metrics` namespace.
 
 #### RecordQueueLatency
 
@@ -237,6 +237,26 @@ execution time.
 > to retrieve the enqueue timestamp. In high-throughput scenarios, this may impact
 > performance.
 
+> [!NOTE]
+> Add `using OpenTelemetry.Metrics;` to access `HangfireMetricsInstrumentationOptions`.
+
+#### DisplayNameFunc
+
+Metrics use the `DisplayNameFunc` from `HangfireMetricsInstrumentationOptions` to populate
+`workflow.task.name` and related attributes. By default, it calls `backgroundJob.Job.ToString()`,
+but you can provide your own formatter:
+
+```csharp
+var meterProvider = Sdk.CreateMeterProviderBuilder()
+    .AddHangfireInstrumentation(options =>
+    {
+        options.DisplayNameFunc = backgroundJob => $"{backgroundJob.Job.Type.Name}:{backgroundJob.Id}";
+    })
+    .AddConsoleExporter()
+    .Build();
+```
+
+
 ### Available Metrics
 
 The following metrics are emitted by this instrumentation:
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/DependencyInjectionConfigTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/DependencyInjectionConfigTests.cs
index efaf6d8776..bd2a5d5bab 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/DependencyInjectionConfigTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/DependencyInjectionConfigTests.cs
@@ -3,6 +3,7 @@
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
 using Xunit;
 
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index dc60ad21be..14849a27ef 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -304,6 +304,34 @@ public async Task Should_Record_All_Metrics_For_Multiple_Jobs()
         Assert.True(totalExecutions >= 3, $"Expected at least 3 executions, got {totalExecutions}");
     }
 
+    [Fact]
+    public async Task Should_Use_Custom_DisplayName_For_Metrics()
+    {
+        // Arrange
+        const string customName = "CustomJobName";
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation(options =>
+            {
+                options.DisplayNameFunc = _ => customName;
+            })
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
+
+        meterProvider.ForceFlush();
+
+        // Assert
+        var executionCountMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionCountMetricName);
+        AssertUtils.AssertHasMetricPoints(executionCountMetric);
+
+        var metricPoint = executionCountMetric!.ToMetricPointList().First();
+        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowTaskName, customName);
+    }
+
     [Fact]
     public async Task Should_Track_Success_And_Failure_Outcomes_Separately()
     {
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
index 698970e54f..3048e20a06 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
@@ -248,7 +248,7 @@ public async Task Should_Record_PendingDuration_For_Multiple_Jobs()
     public void Should_NOT_Register_PendingDurationFilter_When_Disabled()
     {
         // Arrange
-        var options = new Trace.HangfireInstrumentationOptions
+        var options = new HangfireMetricsInstrumentationOptions
         {
             RecordQueueLatency = false,
         };
@@ -266,7 +266,7 @@ public void Should_NOT_Register_PendingDurationFilter_When_Disabled()
     public void Should_Register_PendingDurationFilter_When_Enabled()
     {
         // Arrange
-        var options = new Trace.HangfireInstrumentationOptions
+        var options = new HangfireMetricsInstrumentationOptions
         {
             RecordQueueLatency = true,
         };

From bc135e8aa47e3995dc56ab28b65037f8c0ce62a8 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Fri, 24 Oct 2025 18:36:56 -0400
Subject: [PATCH 04/48] Add workflow.status metric to track complete job
 lifecycle

---
 .../Implementation/HangfireMetrics.cs         |  30 ++-
 .../HangfireMetricsJobFilterAttribute.cs      |   2 +-
 .../HangfireMetricsStateFilter.cs             | 148 ++++++++---
 .../HangfirePendingDurationFilterAttribute.cs |   2 +-
 .../Implementation/HangfireStateMapper.cs     |  77 ++++++
 .../Implementation/HangfireTagBuilder.cs      | 124 ++++-----
 .../Implementation/WorkflowAttributes.cs      | 158 +++++++++++
 .../Implementation/WorkflowMetricNames.cs     |  43 +++
 .../README.md                                 | 107 +++++++-
 .../HangfireFixture.cs                        |  33 +++
 .../HangfireMetricsErrorTests.cs              |  28 +-
 .../HangfireMetricsTests.cs                   | 247 ++++++++++++++----
 .../HangfireQueueLatencyTests.cs              |  44 ++--
 13 files changed, 821 insertions(+), 222 deletions(-)
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
index 0125fb9b41..b5cef73887 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
@@ -12,13 +12,6 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal static class HangfireMetrics
 {
-    // Metric name constants
-    internal const string ExecutionCountMetricName = "workflow.execution.count";
-    internal const string ExecutionDurationMetricName = "workflow.execution.duration";
-    internal const string ExecutionStatusMetricName = "workflow.execution.status";
-    internal const string ExecutionErrorsMetricName = "workflow.execution.errors";
-    internal const string WorkflowCountMetricName = "workflow.count";
-
     internal static readonly Assembly Assembly = typeof(HangfireMetrics).Assembly;
     internal static readonly AssemblyName AssemblyName = Assembly.GetName();
     internal static readonly string MeterName = AssemblyName.Name!;
@@ -28,7 +21,7 @@ internal static class HangfireMetrics
     /// <summary>
     /// The meter instance for all Hangfire metrics.
     /// </summary>
-    public static readonly Meter Meter = new(MeterName, InstrumentationVersion);
+    private static readonly Meter Meter = new(MeterName, InstrumentationVersion);
 
     /// <summary>
     /// Counter for the number of task executions which have been initiated.
@@ -36,7 +29,7 @@ internal static class HangfireMetrics
     /// </summary>
     public static readonly Counter<long> ExecutionCount =
         Meter.CreateCounter<long>(
-            ExecutionCountMetricName,
+            WorkflowMetricNames.ExecutionCount,
             unit: "{executions}",
             description: "The number of task executions which have been initiated.");
 
@@ -49,7 +42,7 @@ internal static class HangfireMetrics
     /// </summary>
     public static readonly Histogram<double> ExecutionDuration =
         Meter.CreateHistogram<double>(
-            ExecutionDurationMetricName,
+            WorkflowMetricNames.ExecutionDuration,
             unit: "s",
             description: "Duration of an execution grouped by task, type and result.");
 
@@ -59,7 +52,7 @@ internal static class HangfireMetrics
     /// </summary>
     public static readonly UpDownCounter<long> ExecutionStatus =
         Meter.CreateUpDownCounter<long>(
-            ExecutionStatusMetricName,
+            WorkflowMetricNames.ExecutionStatus,
             unit: "{executions}",
             description: "The number of actively running tasks grouped by task, type and the current state.");
 
@@ -69,7 +62,7 @@ internal static class HangfireMetrics
     /// </summary>
     public static readonly Counter<long> ExecutionErrors =
         Meter.CreateCounter<long>(
-            ExecutionErrorsMetricName,
+            WorkflowMetricNames.ExecutionErrors,
             unit: "{error}",
             description: "The number of errors encountered in task runs (eg. compile, test failures).");
 
@@ -80,7 +73,18 @@ internal static class HangfireMetrics
     /// </summary>
     public static readonly Counter<long> WorkflowCount =
         Meter.CreateCounter<long>(
-            WorkflowCountMetricName,
+            WorkflowMetricNames.WorkflowCount,
             unit: "{workflows}",
             description: "The number of workflow instances which have been initiated.");
+
+    /// <summary>
+    /// UpDownCounter for the number of actively running workflows grouped by definition and state.
+    /// Follows OpenTelemetry workflow semantic conventions.
+    /// In Hangfire, this tracks workflows that haven't entered the execution pipeline yet (e.g., scheduled jobs).
+    /// </summary>
+    public static readonly UpDownCounter<long> WorkflowStatus =
+        Meter.CreateUpDownCounter<long>(
+            WorkflowMetricNames.WorkflowStatus,
+            unit: "{workflows}",
+            description: "The number of actively running workflows grouped by definition and the current state.");
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
index cc7bdb8ce8..ba0684424b 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
@@ -64,7 +64,7 @@ public void OnPerformed(PerformedContext performedContext)
                 backgroundJob,
                 displayNameFunc,
                 performedContext.Exception,
-                workflowState: HangfireTagBuilder.StateExecuting);
+                workflowState: WorkflowAttributes.WorkflowStateValues.Executing);
 
             HangfireMetrics.ExecutionDuration.Record(duration, durationTags);
         }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index 0be33a86df..42dc3514b3 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -13,49 +13,10 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal sealed class HangfireMetricsStateFilter : JobFilterAttribute, IApplyStateFilter
 {
-    private readonly HangfireMetricsInstrumentationOptions options;
-
-#pragma warning disable CA1019 // Define accessors for attribute arguments
-    public HangfireMetricsStateFilter(HangfireMetricsInstrumentationOptions options)
-#pragma warning restore CA1019 // Define accessors for attribute arguments
-    {
-        this.options = options ?? throw new ArgumentNullException(nameof(options));
-    }
-
-    public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
-    {
-        var workflowState = HangfireTagBuilder.MapWorkflowState(context.NewState.Name);
-        if (workflowState == null)
-        {
-            return;
-        }
-
-        var errorType = GetErrorTypeFromNewState(context.NewState);
-        var tags = HangfireTagBuilder.BuildStateTags(
-            context.BackgroundJob,
-            this.options.DisplayNameFunc,
-            workflowState,
-            errorType);
-
-        HangfireMetrics.ExecutionStatus.Add(1, tags);
-    }
-
-    public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
+    private enum StateTransitionDirection
     {
-        var workflowState = HangfireTagBuilder.MapWorkflowState(context.OldStateName);
-        if (workflowState == null)
-        {
-            return;
-        }
-
-        var errorType = GetErrorTypeFromOldState(context);
-        var tags = HangfireTagBuilder.BuildStateTags(
-            context.BackgroundJob,
-            this.options.DisplayNameFunc,
-            workflowState,
-            errorType);
-
-        HangfireMetrics.ExecutionStatus.Add(-1, tags);
+        Applied,
+        Unapplied,
     }
 
     private static string? GetErrorTypeFromNewState(IState state)
@@ -65,7 +26,7 @@ public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction tr
             return null;
         }
 
-        if (state is FailedState failedState && failedState.Exception != null)
+        if (state is FailedState { Exception: not null } failedState)
         {
             var exceptionType = failedState.Exception.GetType();
             return exceptionType.FullName ?? exceptionType.Name;
@@ -99,4 +60,105 @@ public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction tr
 
         return null;
     }
+
+    private static string? TryGetRecurringJobId(ApplyStateContext context)
+    {
+        try
+        {
+            return context.Connection.GetJobParameter(
+                context.BackgroundJob.Id,
+                "RecurringJobId");
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private readonly HangfireMetricsInstrumentationOptions options;
+
+#pragma warning disable CA1019 // Define accessors for attribute arguments
+    public HangfireMetricsStateFilter(HangfireMetricsInstrumentationOptions options)
+#pragma warning restore CA1019 // Define accessors for attribute arguments
+    {
+        this.options = options ?? throw new ArgumentNullException(nameof(options));
+    }
+
+    public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
+    {
+        this.RecordWorkflowStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Applied);
+        this.RecordExecutionStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Applied);
+    }
+
+    public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
+    {
+        this.RecordWorkflowStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Unapplied);
+        this.RecordExecutionStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Unapplied);
+    }
+
+    private void RecordWorkflowStateChange(
+        ApplyStateContext context,
+        string? oldStateName,
+        string? newStateName,
+        StateTransitionDirection direction)
+    {
+        var oldState = HangfireStateMapper.MapWorkflowState(oldStateName);
+        var newState = HangfireStateMapper.MapWorkflowState(newStateName);
+
+        // Determine which state to record based on transition direction
+        var stateToRecord = direction == StateTransitionDirection.Applied ? newState : oldState;
+
+        // Only record if semantic state actually changed
+        if (stateToRecord == null || oldState == newState)
+        {
+            return;
+        }
+
+        var recurringJobId = TryGetRecurringJobId(context);
+        var errorType = direction == StateTransitionDirection.Applied
+            ? GetErrorTypeFromNewState(context.NewState)
+            : GetErrorTypeFromOldState(context);
+
+        var tags = HangfireTagBuilder.BuildWorkflowStatusTags(
+            context.BackgroundJob,
+            this.options.DisplayNameFunc,
+            stateToRecord,
+            recurringJobId,
+            errorType);
+
+        var delta = direction == StateTransitionDirection.Applied ? 1 : -1;
+        HangfireMetrics.WorkflowStatus.Add(delta, tags);
+    }
+
+    private void RecordExecutionStateChange(
+        ApplyStateContext context,
+        string? oldStateName,
+        string? newStateName,
+        StateTransitionDirection direction)
+    {
+        var oldState = HangfireStateMapper.MapExecutionState(oldStateName);
+        var newState = HangfireStateMapper.MapExecutionState(newStateName);
+
+        // Determine which state to record based on transition direction
+        var stateToRecord = direction == StateTransitionDirection.Applied ? newState : oldState;
+
+        // Only record if semantic state actually changed
+        if (stateToRecord == null || oldState == newState)
+        {
+            return;
+        }
+
+        var errorType = direction == StateTransitionDirection.Applied
+            ? GetErrorTypeFromNewState(context.NewState)
+            : GetErrorTypeFromOldState(context);
+
+        var tags = HangfireTagBuilder.BuildExecutionstatusTags(
+            context.BackgroundJob,
+            this.options.DisplayNameFunc,
+            stateToRecord,
+            errorType);
+
+        var delta = direction == StateTransitionDirection.Applied ? 1 : -1;
+        HangfireMetrics.ExecutionStatus.Add(delta, tags);
+    }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
index 3f4f7296b1..73d1a9ce6d 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
@@ -69,7 +69,7 @@ public void OnPerforming(PerformingContext performingContext)
                     performingContext.BackgroundJob,
                     this.options.DisplayNameFunc,
                     exception: null,
-                    workflowState: HangfireTagBuilder.StatePending);
+                    workflowState: WorkflowAttributes.WorkflowStateValues.Pending);
                 HangfireMetrics.ExecutionDuration.Record(pendingDuration, tags);
             }
         }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs
new file mode 100644
index 0000000000..57843276d3
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs
@@ -0,0 +1,77 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using Hangfire.States;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Maps Hangfire-specific state names to OpenTelemetry workflow semantic convention state values.
+/// </summary>
+internal static class HangfireStateMapper
+{
+    /// <summary>
+    /// Maps Hangfire state names to workflow execution semantic convention state values.
+    /// Note: ScheduledState is NOT mapped here as it represents a workflow-level state,
+    /// not an execution-level state. Use MapWorkflowState() for scheduled jobs.
+    /// </summary>
+    /// <param name="hangfireState">Hangfire state name.</param>
+    /// <returns>Mapped workflow execution state value, or <see langword="null"/> if the state is not recognized.</returns>
+    public static string? MapExecutionState(string? hangfireState)
+    {
+        if (hangfireState == EnqueuedState.StateName ||
+            hangfireState == AwaitingState.StateName)
+        {
+            return WorkflowAttributes.WorkflowStateValues.Pending;
+        }
+
+        if (hangfireState == ProcessingState.StateName)
+        {
+            return WorkflowAttributes.WorkflowStateValues.Executing;
+        }
+
+        if (hangfireState == SucceededState.StateName ||
+            hangfireState == DeletedState.StateName ||
+            hangfireState == FailedState.StateName)
+        {
+            return WorkflowAttributes.WorkflowStateValues.Completed;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Maps Hangfire state names to workflow-level semantic convention state values.
+    /// Tracks the complete workflow lifecycle: scheduled jobs waiting for trigger time,
+    /// enqueued jobs waiting in queue, executing jobs, and completed jobs.
+    /// Note: "pending" at workflow level includes both scheduled (waiting for time) and enqueued (waiting for worker).
+    /// </summary>
+    /// <param name="hangfireState">Hangfire state name.</param>
+    /// <returns>Mapped workflow state value, or <see langword="null"/> if the state is not recognized.</returns>
+    public static string? MapWorkflowState(string? hangfireState)
+    {
+        // Scheduled and Enqueued/Awaiting are both "pending" at workflow level
+        // Scheduled = waiting for scheduled time to arrive (trigger.type=schedule)
+        // Enqueued = waiting in queue for worker (trigger.type=api/cron)
+        if (hangfireState == ScheduledState.StateName ||
+            hangfireState == EnqueuedState.StateName ||
+            hangfireState == AwaitingState.StateName)
+        {
+            return WorkflowAttributes.WorkflowStateValues.Pending;
+        }
+
+        if (hangfireState == ProcessingState.StateName)
+        {
+            return WorkflowAttributes.WorkflowStateValues.Executing;
+        }
+
+        if (hangfireState == SucceededState.StateName ||
+            hangfireState == DeletedState.StateName ||
+            hangfireState == FailedState.StateName)
+        {
+            return WorkflowAttributes.WorkflowStateValues.Completed;
+        }
+
+        return null;
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index 8e5281a8d6..4328f97046 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -4,7 +4,6 @@
 using System.Diagnostics;
 using Hangfire;
 using Hangfire.Server;
-using Hangfire.States;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
@@ -14,32 +13,6 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal static class HangfireTagBuilder
 {
-    // Tag name constants following OpenTelemetry workflow semantic conventions
-    // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md
-    internal const string TagWorkflowTaskName = "workflow.task.name";
-    internal const string TagWorkflowDefinitionName = "workflow.definition.name";
-    internal const string TagWorkflowExecutionOutcome = "workflow.execution.outcome";
-    internal const string TagWorkflowOutcome = "workflow.outcome";
-    internal const string TagWorkflowExecutionState = "workflow.execution.state";
-    internal const string TagWorkflowPlatformName = "workflow.platform.name";
-    internal const string TagWorkflowTriggerType = "workflow.trigger.type";
-    internal const string TagErrorType = "error.type";
-
-    // Outcome values per semantic conventions
-    internal const string OutcomeSuccess = "success";
-    internal const string OutcomeFailure = "failure";
-
-    // State values per semantic conventions
-    internal const string StatePending = "pending";
-    internal const string StateExecuting = "executing";
-    internal const string StateCompleted = "completed";
-
-    // Platform name constant
-    internal const string PlatformHangfire = "hangfire";
-
-    // Trigger type constants
-    internal const string TriggerTypeCron = "cron";
-    internal const string TriggerTypeApi = "api";
 
     /// <summary>
     /// Creates a tag list with common job metadata following workflow semantic conventions.
@@ -68,7 +41,7 @@ public static TagList BuildCommonTags(BackgroundJob backgroundJob, Func<Backgrou
     /// <param name="workflowState">The workflow state value.</param>
     /// <param name="errorType">Optional error type to annotate failure states.</param>
     /// <returns>Tag list suitable for workflow.execution.status metric.</returns>
-    public static TagList BuildStateTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, string workflowState, string? errorType)
+    public static TagList BuildExecutionstatusTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, string workflowState, string? errorType)
     {
         var tags = new TagList
         {
@@ -79,40 +52,12 @@ public static TagList BuildStateTags(BackgroundJob backgroundJob, Func<Backgroun
 
         if (!string.IsNullOrEmpty(errorType))
         {
-            tags.Add(new KeyValuePair<string, object?>(TagErrorType, errorType));
+            tags.Add(new KeyValuePair<string, object?>(WorkflowAttributes.AttributeErrorType, errorType));
         }
 
         return tags;
     }
 
-    /// <summary>
-    /// Maps Hangfire state names to workflow semantic convention state values.
-    /// </summary>
-    /// <param name="hangfireState">Hangfire state name.</param>
-    /// <returns>Mapped workflow state value, or <see langword="null"/> if the state is not recognized.</returns>
-    public static string? MapWorkflowState(string? hangfireState)
-    {
-        if (hangfireState == ScheduledState.StateName ||
-            hangfireState == EnqueuedState.StateName ||
-            hangfireState == AwaitingState.StateName)
-        {
-            return StatePending;
-        }
-
-        if (hangfireState == ProcessingState.StateName)
-        {
-            return StateExecuting;
-        }
-
-        if (hangfireState == SucceededState.StateName ||
-            hangfireState == DeletedState.StateName ||
-            hangfireState == FailedState.StateName)
-        {
-            return StateCompleted;
-        }
-
-        return null;
-    }
 
     /// <summary>
     /// Creates a tag list with execution result tags following workflow semantic conventions.
@@ -202,6 +147,42 @@ public static TagList BuildWorkflowTags(BackgroundJob job, Func<BackgroundJob, s
         return tags;
     }
 
+    /// <summary>
+    /// Creates a tag list for workflow.status metric following workflow semantic conventions.
+    /// Includes required attributes (workflow.definition.name, workflow.state, workflow.trigger.type),
+    /// recommended attributes (workflow.platform.name),
+    /// conditionally required attributes (error.type if failed).
+    /// Used for tracking workflow state transitions (e.g., scheduled jobs).
+    /// </summary>
+    /// <param name="backgroundJob">The Hangfire background job.</param>
+    /// <param name="displayNameFunc">Function to generate display name.</param>
+    /// <param name="workflowState">The workflow state value (e.g., "pending", "executing", "completed").</param>
+    /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
+    /// <param name="errorType">Optional error type to annotate failure states.</param>
+    /// <returns>Tag list suitable for workflow.status metric.</returns>
+    public static TagList BuildWorkflowStatusTags(
+        BackgroundJob backgroundJob,
+        Func<BackgroundJob, string> displayNameFunc,
+        string workflowState,
+        string? recurringJobId,
+        string? errorType)
+    {
+        var tags = new TagList
+        {
+            GetDefinitionName(backgroundJob, displayNameFunc),
+            GetPlatformName(),
+            new KeyValuePair<string, object?>(WorkflowAttributes.AttributeWorkflowState, workflowState),
+            GetTriggerType(recurringJobId, isScheduled: workflowState == WorkflowAttributes.WorkflowStateValues.Pending && string.IsNullOrEmpty(recurringJobId)),
+        };
+
+        if (!string.IsNullOrEmpty(errorType))
+        {
+            tags.Add(new KeyValuePair<string, object?>(WorkflowAttributes.AttributeErrorType, errorType));
+        }
+
+        return tags;
+    }
+
     /// <summary>
     /// Creates a tag list for workflow.execution.errors metric following workflow semantic conventions.
     /// Includes required attributes (error.type, workflow.task.name),
@@ -224,36 +205,41 @@ public static TagList BuildErrorTags(BackgroundJob backgroundJob, Func<Backgroun
 
     // Required workflow attributes
     private static KeyValuePair<string, object?> GetTaskName(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc) =>
-        new(TagWorkflowTaskName, displayNameFunc(backgroundJob));
+        new(WorkflowAttributes.AttributeWorkflowTaskName, displayNameFunc(backgroundJob));
 
     private static KeyValuePair<string, object?> GetDefinitionName(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc) =>
-        new(TagWorkflowDefinitionName, displayNameFunc(backgroundJob));
-
+        new(WorkflowAttributes.AttributeWorkflowDefinitionName, displayNameFunc(backgroundJob));
 
     private static KeyValuePair<string, object?> GetExecutionOutcome(Exception? exception) =>
-        new(TagWorkflowExecutionOutcome, exception is null ? OutcomeSuccess : OutcomeFailure);
+        new(WorkflowAttributes.AttributeWorkflowExecutionOutcome, exception is null ? WorkflowAttributes.WorkflowOutcomeValues.Success : WorkflowAttributes.WorkflowOutcomeValues.Failure);
 
     private static KeyValuePair<string, object?> GetWorkflowOutcome(Exception? exception) =>
-        new(TagWorkflowOutcome, exception is null ? OutcomeSuccess : OutcomeFailure);
+        new(WorkflowAttributes.AttributeWorkflowOutcome, exception is null ? WorkflowAttributes.WorkflowOutcomeValues.Success : WorkflowAttributes.WorkflowOutcomeValues.Failure);
 
-    private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId)
+    private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId, bool isScheduled = false)
     {
         // Check if job was triggered by a recurring job (cron)
         if (!string.IsNullOrEmpty(recurringJobId))
         {
-            return new(TagWorkflowTriggerType, TriggerTypeCron);
+            return new(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Cron);
+        }
+
+        // Check if job is scheduled for future execution
+        if (isScheduled)
+        {
+            return new(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Schedule);
         }
 
-        // Default to API trigger (fire-and-forget, scheduled, continuations)
-        return new(TagWorkflowTriggerType, TriggerTypeApi);
+        // Default to API trigger (fire-and-forget, continuations)
+        return new(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Api);
     }
 
     // Recommended workflow attributes
     private static KeyValuePair<string, object?> GetPlatformName() =>
-        new(TagWorkflowPlatformName, PlatformHangfire);
+        new(WorkflowAttributes.AttributeWorkflowPlatformName, WorkflowAttributes.WorkflowPlatformNameValues.Hangfire);
 
     private static KeyValuePair<string, object?> GetState(string workflowState) =>
-        new(TagWorkflowExecutionState, workflowState);
+        new(WorkflowAttributes.AttributeWorkflowExecutionState, workflowState);
 
     // Conditionally required workflow attributes
     private static KeyValuePair<string, object?> GetErrorType(Exception exception)
@@ -265,6 +251,6 @@ public static TagList BuildErrorTags(BackgroundJob backgroundJob, Func<Backgroun
             loggedException = pe.InnerException!;
         }
 
-        return new KeyValuePair<string, object?>(TagErrorType, loggedException.GetType().FullName ?? loggedException.GetType().Name);
+        return new KeyValuePair<string, object?>(WorkflowAttributes.AttributeErrorType, loggedException.GetType().FullName ?? loggedException.GetType().Name);
     }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs
new file mode 100644
index 0000000000..5dcd747c53
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs
@@ -0,0 +1,158 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Constants for workflow semantic attribute names and values outlined by the OpenTelemetry specifications.
+/// </summary>
+/// <remarks>
+/// See: https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md.
+/// </remarks>
+internal static class WorkflowAttributes
+{
+    // ===== Attribute Names =====
+
+    /// <summary>
+    /// Name of the task.
+    /// </summary>
+    public const string AttributeWorkflowTaskName = "workflow.task.name";
+
+    /// <summary>
+    /// Name of the workflow.
+    /// </summary>
+    public const string AttributeWorkflowDefinitionName = "workflow.definition.name";
+
+    /// <summary>
+    /// The outcome of executing the task.
+    /// </summary>
+    public const string AttributeWorkflowExecutionOutcome = "workflow.execution.outcome";
+
+    /// <summary>
+    /// The result of a workflow run.
+    /// </summary>
+    public const string AttributeWorkflowOutcome = "workflow.outcome";
+
+    /// <summary>
+    /// The execution state.
+    /// </summary>
+    public const string AttributeWorkflowExecutionState = "workflow.execution.state";
+
+    /// <summary>
+    /// The workflow state.
+    /// </summary>
+    public const string AttributeWorkflowState = "workflow.state";
+
+    /// <summary>
+    /// The product being used to co-ordinate the execution of the tasks.
+    /// </summary>
+    public const string AttributeWorkflowPlatformName = "workflow.platform.name";
+
+    /// <summary>
+    /// Type of trigger that was called.
+    /// </summary>
+    public const string AttributeWorkflowTriggerType = "workflow.trigger.type";
+
+    /// <summary>
+    /// Describes a class of error the operation ended with.
+    /// </summary>
+    public const string AttributeErrorType = "error.type";
+
+    // ===== Attribute Value Constants =====
+
+    /// <summary>
+    /// Values for workflow.execution.outcome and workflow.outcome attributes.
+    /// </summary>
+    public static class WorkflowOutcomeValues
+    {
+        /// <summary>
+        /// The execution/workflow finished successfully.
+        /// </summary>
+        public const string Success = "success";
+
+        /// <summary>
+        /// The execution/workflow did not finish successfully, eg. due to a compile error or a failing test.
+        /// </summary>
+        public const string Failure = "failure";
+
+        /// <summary>
+        /// The execution/workflow was cancelled, eg. by a user manually cancelling the execution.
+        /// </summary>
+        public const string Cancellation = "cancellation";
+
+        /// <summary>
+        /// The execution/workflow failed due to an error in the system, eg. due to the worker being killed.
+        /// </summary>
+        public const string Error = "error";
+
+        /// <summary>
+        /// A timeout caused the execution/workflow to be interrupted.
+        /// </summary>
+        public const string Timeout = "timeout";
+
+        /// <summary>
+        /// The execution/workflow was skipped, eg. due to a precondition not being met.
+        /// </summary>
+        public const string Skip = "skip";
+    }
+
+    /// <summary>
+    /// Values for workflow.execution.state and workflow.state attributes.
+    /// </summary>
+    public static class WorkflowStateValues
+    {
+        /// <summary>
+        /// The pending state spans from when the workflow/execution is triggered until it starts executing.
+        /// For workflows: includes time waiting for scheduled time (scheduled jobs).
+        /// For executions: includes time spent in queue waiting for a worker (enqueued jobs).
+        /// </summary>
+        public const string Pending = "pending";
+
+        /// <summary>
+        /// The executing state spans the actual execution of the workflow/task (eg. build, test).
+        /// </summary>
+        public const string Executing = "executing";
+
+        /// <summary>
+        /// The finalizing state spans from when execution has finished and covers cleanup of resources, etc.
+        /// </summary>
+        public const string Finalizing = "finalizing";
+
+        /// <summary>
+        /// The completed state spans from when the workflow/execution has finished finalizing (eg. cleanup of resources).
+        /// </summary>
+        public const string Completed = "completed";
+    }
+
+    /// <summary>
+    /// Values for workflow.platform.name attribute.
+    /// </summary>
+    public static class WorkflowPlatformNameValues
+    {
+        /// <summary>
+        /// Hangfire platform.
+        /// </summary>
+        public const string Hangfire = "hangfire";
+    }
+
+    /// <summary>
+    /// Values for workflow.trigger.type attribute.
+    /// </summary>
+    public static class WorkflowTriggerTypeValues
+    {
+        /// <summary>
+        /// Cron trigger (recurring jobs).
+        /// </summary>
+        public const string Cron = "cron";
+
+        /// <summary>
+        /// API trigger (fire-and-forget, continuation jobs).
+        /// </summary>
+        public const string Api = "api";
+
+        /// <summary>
+        /// Schedule trigger (delayed jobs).
+        /// </summary>
+        public const string Schedule = "schedule";
+    }
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs
new file mode 100644
index 0000000000..cb4dae257a
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs
@@ -0,0 +1,43 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+/// <summary>
+/// Constants for workflow metric names outlined by the OpenTelemetry specifications.
+/// </summary>
+/// <remarks>
+/// See: https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md.
+/// </remarks>
+internal static class WorkflowMetricNames
+{
+    /// <summary>
+    /// The number of task executions which have been initiated.
+    /// </summary>
+    public const string ExecutionCount = "workflow.execution.count";
+
+    /// <summary>
+    /// Duration of an execution grouped by task, type and result.
+    /// </summary>
+    public const string ExecutionDuration = "workflow.execution.duration";
+
+    /// <summary>
+    /// The number of actively running tasks grouped by task, type and the current state.
+    /// </summary>
+    public const string ExecutionStatus = "workflow.execution.status";
+
+    /// <summary>
+    /// The number of errors encountered in task runs (eg. compile, test failures).
+    /// </summary>
+    public const string ExecutionErrors = "workflow.execution.errors";
+
+    /// <summary>
+    /// The number of workflow instances which have been initiated.
+    /// </summary>
+    public const string WorkflowCount = "workflow.count";
+
+    /// <summary>
+    /// The number of actively running workflows grouped by definition and the current state.
+    /// </summary>
+    public const string WorkflowStatus = "workflow.status";
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 91aed3e9e3..bb36e01782 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -168,7 +168,14 @@ using var tracerProvider = Sdk
 
 This instrumentation library collects metrics following the OpenTelemetry
 [workflow semantic conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md).
-In Hangfire, each background job execution is modeled as a **workflow task execution**.
+
+In Hangfire, the workflow semantic conventions are applied as follows:
+- Each background job execution is modeled as a **workflow task execution**
+- Workflow-level metrics track the complete lifecycle (including scheduled jobs)
+- Execution-level metrics track the execution pipeline (enqueued jobs and later)
+
+This approach provides comprehensive visibility into both job creation/scheduling and
+actual execution performance.
 
 ### Enabling Metrics
 
@@ -261,6 +268,18 @@ var meterProvider = Sdk.CreateMeterProviderBuilder()
 
 The following metrics are emitted by this instrumentation:
 
+**Execution-level metrics** track jobs that have entered the execution pipeline:
+- `workflow.execution.count` - Counter for completed executions
+- `workflow.execution.duration` - Histogram for execution duration (pending and executing phases)
+- `workflow.execution.status` - UpDownCounter for current execution state
+- `workflow.execution.errors` - Counter for execution errors
+
+**Workflow-level metrics** track the complete job lifecycle:
+- `workflow.count` - Counter for completed workflows
+- `workflow.status` - UpDownCounter for current workflow state (including scheduled jobs)
+
+---
+
 #### workflow.execution.count
 
 The number of task executions which have been initiated.
@@ -376,27 +395,101 @@ individual job completions.
 |-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
 | `workflow.definition.name`    | string | Name of the workflow (Hangfire job method)    | Required                 | e.g., `MyJob.Execute`   |
 | `workflow.outcome`            | string | The outcome of the workflow                   | Required                 | `success`, `failure`    |
-| `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`           |
+| `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`, `schedule` |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
 | `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
 
 ¹ Required if and only if the workflow execution failed.
 
+#### workflow.status
+
+The number of actively running workflows grouped by definition and the current state.
+
+| Units          | Instrument Type  | Value Type |
+|----------------|------------------|------------|
+| `{workflows}`  | UpDownCounter    | `Int64`    |
+
+> [!NOTE]
+> This metric tracks the workflow lifecycle including jobs that haven't entered the execution
+> pipeline yet (e.g., scheduled jobs waiting for their trigger time). When a workflow transitions
+> to a new state, the previous state is decremented and the new state is incremented.
+
+**Attributes:**
+
+| Attribute                     | Type   | Description                                   | Requirement Level        | Values                                    |
+|-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------------------------|
+| `workflow.definition.name`    | string | Name of the workflow (Hangfire job method)    | Required                 | e.g., `MyJob.Execute`                     |
+| `workflow.state`              | string | Current state of the workflow                 | Required                 | `pending`, `executing`, `completed`       |
+| `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`, `schedule`                 |
+| `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`                                |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name                       |
+
+¹ Required if and only if the workflow execution failed.
+
+**Hangfire State Mapping:**
+
+Hangfire job states are mapped to workflow semantic convention states as follows:
+
+| Hangfire State                     | Workflow State | Workflow Trigger Type           |
+|------------------------------------|----------------|---------------------------------|
+| Scheduled                          | `pending`      | `schedule`                      |
+| Enqueued, Awaiting (from cron)     | `pending`      | `cron`                          |
+| Enqueued, Awaiting (fire-and-forget)| `pending`     | `api`                           |
+| Processing                         | `executing`    | (inherited from previous state) |
+| Succeeded, Failed, Deleted         | `completed`    | (inherited from previous state) |
+
+> [!IMPORTANT]
+> **Difference between `workflow.status` and `workflow.execution.status`:**
+>
+> - **`workflow.status`**: Tracks the complete workflow lifecycle, including jobs that haven't
+>   started execution yet (e.g., scheduled jobs waiting for their trigger time). This provides
+>   visibility into jobs across all states.
+>
+> - **`workflow.execution.status`**: Tracks only jobs that have entered the execution pipeline
+>   (enqueued or later). Scheduled jobs do NOT appear here until they become enqueued.
+>
+> For example, a scheduled job appears in `workflow.status{state=pending, trigger.type=schedule}`
+> but NOT in `workflow.execution.status` until it becomes enqueued. Once enqueued, it appears
+> in both metrics.
+
 ### Semantic Conventions
 
 This instrumentation follows the OpenTelemetry semantic conventions for workflows:
 
+#### Attribute Usage
+
 - **workflow.platform.name**: Always set to `"hangfire"`
 - **workflow.task.name** / **workflow.definition.name**: Derived from the Hangfire job method (e.g., `ClassName.MethodName`)
-- **workflow.trigger.type**: Set to `"cron"` for recurring jobs, `"api"` for fire-and-forget,
-  scheduled, and continuation jobs. Only included on workflow-level metrics (`workflow.count`),
-  not on execution-level metrics (`workflow.execution.*`)
+  - `workflow.task.name` is used for execution-level metrics (`workflow.execution.*`)
+  - `workflow.definition.name` is used for workflow-level metrics (`workflow.count`, `workflow.status`)
+- **workflow.trigger.type**: Identifies how the job was initiated
+  - `"cron"` for recurring jobs
+  - `"schedule"` for delayed jobs (scheduled for future execution)
+  - `"api"` for fire-and-forget and continuation jobs
+  - Only included on workflow-level metrics (`workflow.count`, `workflow.status`), not on execution-level metrics (`workflow.execution.*`)
 - **workflow.execution.outcome** / **workflow.outcome**: Set to `"success"` when jobs complete without errors,
   `"failure"` when an exception is thrown
-- **workflow.execution.state**: Maps Hangfire states to semantic convention states
-  (see table above). Also used to distinguish between pending (queue wait) and executing (actual execution) phases in duration metrics
+- **workflow.execution.state** / **workflow.state**: Maps Hangfire states to semantic convention states
+  - `workflow.execution.state` tracks execution pipeline states (used in `workflow.execution.status`, `workflow.execution.duration`)
+  - `workflow.state` tracks complete workflow lifecycle (used in `workflow.status`)
+  - See state mapping tables above for details
 - **error.type**: Set to the full type name of the exception when a job fails
 
+#### Workflow vs Execution Metrics
+
+The instrumentation distinguishes between **workflow-level** and **execution-level** metrics:
+
+**Workflow-level metrics** (`workflow.count`, `workflow.status`):
+- Track the complete lifecycle of jobs, including pre-execution states (e.g., scheduled)
+- Use `workflow.definition.name`, `workflow.state`, and `workflow.trigger.type`
+- Provide visibility into all jobs regardless of execution status
+
+**Execution-level metrics** (`workflow.execution.*`):
+- Track only jobs that have entered the execution pipeline (enqueued or later)
+- Use `workflow.task.name` and `workflow.execution.state`
+- Do NOT include `workflow.trigger.type` (trigger is a workflow-level concept)
+- Provide detailed execution performance metrics
+
 ## References
 
 * [OpenTelemetry Project](https://opentelemetry.io/)
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
index 6f6173acad..26ecd97a52 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
@@ -64,6 +64,39 @@ bool Completed()
         }
     }
 
+    /// <summary>
+    /// Waits for a Hangfire job to reach a specific state.
+    /// </summary>
+    /// <param name="jobId">The ID of the job to wait for.</param>
+    /// <param name="targetState">The target state to wait for (e.g., "Scheduled", "Enqueued").</param>
+    /// <param name="timeToWaitInSeconds">Maximum time to wait in seconds.</param>
+    /// <returns>A task that completes when the job reaches the target state or the timeout expires.</returns>
+    public async Task WaitJobInStateAsync(string jobId, string targetState, int timeToWaitInSeconds)
+    {
+        var timeout = TimeSpan.FromSeconds(timeToWaitInSeconds);
+        using var cts = new CancellationTokenSource(timeout);
+
+        while (!InState() && !cts.IsCancellationRequested)
+        {
+            await Task.Delay(100);
+        }
+
+        bool InState()
+        {
+            var jobDetails = this.MonitoringApi.JobDetails(jobId);
+
+            if (jobDetails == null)
+            {
+                return false;
+            }
+
+            // Copy the history to an array to avoid exception if the collection is modified while iterating
+            var history = jobDetails.History.ToArray();
+
+            return history.Any(h => h.StateName == targetState);
+        }
+    }
+
     public void Dispose()
     {
         this.Server.Dispose();
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs
index 0aea024865..a729214143 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsErrorTests.cs
@@ -36,7 +36,7 @@ public async Task Should_Record_ExecutionErrors_Metric_When_Job_Fails()
         meterProvider.ForceFlush();
 
         // Assert
-        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        var errorMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionErrors);
         AssertUtils.AssertHasMetricPoints(errorMetric);
         Assert.Equal("{error}", errorMetric!.Unit);
         Assert.Equal(MetricType.LongSum, errorMetric.MetricType);
@@ -48,11 +48,11 @@ public async Task Should_Record_ExecutionErrors_Metric_When_Job_Fails()
         Assert.True(sum >= 1, $"Expected workflow.execution.errors sum >= 1, got {sum}");
 
         // Validate required tags
-        AssertUtils.AssertTagContains(metricPoint, HangfireTagBuilder.TagErrorType, "Exception");
-        AssertUtils.AssertTagContains(metricPoint, HangfireTagBuilder.TagWorkflowTaskName, "TestJob.ThrowException");
+        AssertUtils.AssertTagContains(metricPoint, WorkflowAttributes.AttributeErrorType, "Exception");
+        AssertUtils.AssertTagContains(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName, "TestJob.ThrowException");
 
         // Validate recommended tags
-        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName, HangfireTagBuilder.PlatformHangfire);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName, WorkflowAttributes.WorkflowPlatformNameValues.Hangfire);
     }
 
     [Fact]
@@ -71,7 +71,7 @@ public async Task Should_Not_Record_ExecutionErrors_Metric_When_Job_Succeeds()
 
         meterProvider.ForceFlush();
 
-        AssertUtils.AssertMetricNotRecordedOrZero(exportedItems, HangfireMetrics.ExecutionErrorsMetricName);
+        AssertUtils.AssertMetricNotRecordedOrZero(exportedItems, WorkflowMetricNames.ExecutionErrors);
     }
 
     [Fact]
@@ -96,7 +96,7 @@ public async Task Should_Increment_ExecutionErrors_Counter_For_Multiple_Failures
         meterProvider.ForceFlush();
 
         // Assert
-        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        var errorMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionErrors);
         AssertUtils.AssertHasMetricPoints(errorMetric);
 
         var metricPoints = errorMetric!.ToMetricPointList();
@@ -124,13 +124,13 @@ public async Task Should_Record_Different_Error_Types_Separately()
         meterProvider.ForceFlush();
 
         // Assert
-        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        var errorMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionErrors);
         AssertUtils.AssertHasMetricPoints(errorMetric);
         var metricPoints = errorMetric!.ToMetricPointList();
 
         // Should have at least 2 different metric points for different error types
         var distinctErrorTypes = metricPoints
-            .Select(mp => mp.GetTagValue(HangfireTagBuilder.TagErrorType))
+            .Select(mp => mp.GetTagValue(WorkflowAttributes.AttributeErrorType))
             .Distinct()
             .ToList();
 
@@ -161,7 +161,7 @@ public async Task Should_Track_Success_And_Failure_Separately()
         meterProvider.ForceFlush();
 
         // Assert - errors metric should only count the 2 failures
-        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        var errorMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionErrors);
         AssertUtils.AssertHasMetricPoints(errorMetric);
         var metricPoints = errorMetric!.ToMetricPointList();
 
@@ -171,7 +171,7 @@ public async Task Should_Track_Success_And_Failure_Separately()
         // All error metrics should have error.type tag
         foreach (var point in metricPoints)
         {
-            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagErrorType);
+            AssertUtils.AssertHasTag(point, WorkflowAttributes.AttributeErrorType);
         }
     }
 
@@ -192,17 +192,17 @@ public async Task Should_Record_All_Required_And_Recommended_Tags()
         meterProvider.ForceFlush();
 
         // Assert
-        var errorMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionErrorsMetricName);
+        var errorMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionErrors);
         AssertUtils.AssertHasMetricPoints(errorMetric);
         var metricPoints = errorMetric!.ToMetricPointList();
 
         var metricPoint = metricPoints.First();
 
         // Required tags per semantic conventions
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagErrorType);
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeErrorType);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName);
 
         // Recommended tags per semantic conventions
-        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName, HangfireTagBuilder.PlatformHangfire);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName, WorkflowAttributes.WorkflowPlatformNameValues.Hangfire);
     }
 }
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index 14849a27ef..6b866ee9a1 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using Hangfire;
+using Hangfire.States;
 using OpenTelemetry.Instrumentation.Hangfire.Implementation;
 using OpenTelemetry.Instrumentation.Hangfire.Tests.Utils;
 using OpenTelemetry.Metrics;
@@ -36,7 +37,7 @@ public async Task Should_Record_ExecutionCount_Metric_When_Job_Executes()
         meterProvider.ForceFlush();
 
         // Assert
-        var executionCountMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionCountMetricName);
+        var executionCountMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionCount);
         AssertUtils.AssertHasMetricPoints(executionCountMetric);
         Assert.Equal("{executions}", executionCountMetric!.Unit);
         Assert.Equal(MetricType.LongSum, executionCountMetric.MetricType);
@@ -47,9 +48,9 @@ public async Task Should_Record_ExecutionCount_Metric_When_Job_Executes()
 
         // Validate tags
         var metricPoint = metricPoints.First();
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
     }
 
     [Fact]
@@ -69,7 +70,7 @@ public async Task Should_Record_ExecutionDuration_Metric_For_Successful_Job()
         meterProvider.ForceFlush();
 
         // Assert
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
         Assert.Equal("s", durationMetric!.Unit);
         Assert.Equal(MetricType.Histogram, durationMetric.MetricType);
@@ -84,12 +85,12 @@ public async Task Should_Record_ExecutionDuration_Metric_For_Successful_Job()
         Assert.True(sum >= 0, $"Expected histogram sum >= 0, got {sum}");
 
         // Validate tags for successful execution
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
 
         // Error type should NOT be present for successful execution
-        AssertUtils.AssertHasNoTag(metricPoint, HangfireTagBuilder.TagErrorType);
+        AssertUtils.AssertHasNoTag(metricPoint, WorkflowAttributes.AttributeErrorType);
     }
 
     [Fact]
@@ -109,7 +110,7 @@ public async Task Should_Record_ExecutionDuration_Metric_With_ErrorType_For_Fail
         meterProvider.ForceFlush();
 
         // Assert
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
 
         var metricPoints = durationMetric!.ToMetricPointList();
@@ -119,12 +120,12 @@ public async Task Should_Record_ExecutionDuration_Metric_With_ErrorType_For_Fail
         Assert.True(count >= 1, $"Expected histogram count >= 1, got {count}");
 
         // Validate tags for failed execution
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowTaskName);
-        AssertUtils.AssertHasTag(metricPoint, HangfireTagBuilder.TagWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeFailure);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName);
+        AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Failure);
 
         // Error type is conditionally required for failed execution
-        AssertUtils.AssertTagContains(metricPoint, HangfireTagBuilder.TagErrorType, "Exception");
+        AssertUtils.AssertTagContains(metricPoint, WorkflowAttributes.AttributeErrorType, "Exception");
     }
 
     [Fact]
@@ -147,7 +148,7 @@ public async Task Should_Record_PendingDuration_Metric_When_RecordQueueLatency_E
         meterProvider.ForceFlush();
 
         // Assert - Should record workflow.execution.duration with state="pending"
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
         Assert.Equal("s", durationMetric!.Unit);
         Assert.Equal(MetricType.Histogram, durationMetric.MetricType);
@@ -155,7 +156,7 @@ public async Task Should_Record_PendingDuration_Metric_When_RecordQueueLatency_E
         var metricPoints = durationMetric.ToMetricPointList();
 
         // Find the pending state metric point
-        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        var pendingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
         Assert.NotNull(pendingPoint);
 
         var count = pendingPoint.Value.GetHistogramCount();
@@ -165,9 +166,9 @@ public async Task Should_Record_PendingDuration_Metric_When_RecordQueueLatency_E
         Assert.True(sum >= 0, $"Expected histogram sum >= 0 for pending state, got {sum}");
 
         // Validate tags
-        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowTaskName);
-        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowTaskName);
+        AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
     }
 
     [Fact]
@@ -187,7 +188,7 @@ public async Task Should_Record_ExecutionStatus_States_For_Successful_Job()
         meterProvider.ForceFlush();
 
         // Assert
-        var statusMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
+        var statusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
         AssertUtils.AssertHasMetricPoints(statusMetric);
         Assert.Equal(MetricType.LongSumNonMonotonic, statusMetric!.MetricType);
 
@@ -196,31 +197,31 @@ public async Task Should_Record_ExecutionStatus_States_For_Successful_Job()
         // Verify all points have required tags
         foreach (var point in metricPoints)
         {
-            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowTaskName);
-            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowPlatformName);
-            AssertUtils.AssertHasTag(point, HangfireTagBuilder.TagWorkflowExecutionState);
+            AssertUtils.AssertHasTag(point, WorkflowAttributes.AttributeWorkflowTaskName);
+            AssertUtils.AssertHasTag(point, WorkflowAttributes.AttributeWorkflowPlatformName);
+            AssertUtils.AssertHasTag(point, WorkflowAttributes.AttributeWorkflowExecutionState);
 
             // Note: workflow.trigger.type should NOT be on execution-level metrics per semantic conventions
-            AssertUtils.AssertHasNoTag(point, HangfireTagBuilder.TagWorkflowTriggerType);
+            AssertUtils.AssertHasNoTag(point, WorkflowAttributes.AttributeWorkflowTriggerType);
         }
 
         // Verify state transitions balance out to final state
-        var pendingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending)?.GetSumLong() ?? 0;
-        var executingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting)?.GetSumLong() ?? 0;
-        var completedSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted)?.GetSumLong() ?? 0;
+        var pendingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
+        var executingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;
+        var completedSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed)?.GetSumLong() ?? 0;
 
         Assert.Equal(0, pendingSum);
         Assert.Equal(0, executingSum);
         Assert.Equal(1, completedSum);
 
         // Verify completed state has correct attributes
-        var completedPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted);
+        var completedPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
         Assert.NotNull(completedPoint);
 
-        AssertUtils.AssertHasNoTag(completedPoint.Value, HangfireTagBuilder.TagErrorType);
+        AssertUtils.AssertHasNoTag(completedPoint.Value, WorkflowAttributes.AttributeErrorType);
 
         // Note: trigger.type should NOT be on execution-level metrics per semantic conventions
-        AssertUtils.AssertHasNoTag(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType);
+        AssertUtils.AssertHasNoTag(completedPoint.Value, WorkflowAttributes.AttributeWorkflowTriggerType);
     }
 
     [Fact]
@@ -240,30 +241,30 @@ public async Task Should_Record_ExecutionStatus_ErrorType_For_Failed_Job()
         meterProvider.ForceFlush();
 
         // Assert
-        var statusMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
+        var statusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
         AssertUtils.AssertHasMetricPoints(statusMetric);
         Assert.Equal(MetricType.LongSumNonMonotonic, statusMetric!.MetricType);
 
         var metricPoints = statusMetric.ToMetricPointList();
 
         // Verify state transitions balance out to final state (completed with error)
-        var pendingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending)?.GetSumLong() ?? 0;
-        var executingSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting)?.GetSumLong() ?? 0;
-        var completedSum = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted)?.GetSumLong() ?? 0;
+        var pendingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
+        var executingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;
+        var completedSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed)?.GetSumLong() ?? 0;
 
         Assert.Equal(0, pendingSum);
         Assert.Equal(0, executingSum);
         Assert.Equal(1, completedSum);
 
         // Find the completed state metric point (should have error type for failed job)
-        var completedPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateCompleted);
+        var completedPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
         Assert.NotNull(completedPoint);
 
         // Verify error type is present and contains exception information
-        AssertUtils.AssertTagContains(completedPoint.Value, HangfireTagBuilder.TagErrorType, "Exception");
+        AssertUtils.AssertTagContains(completedPoint.Value, WorkflowAttributes.AttributeErrorType, "Exception");
 
         // Note: trigger.type should NOT be on execution-level metrics per semantic conventions
-        AssertUtils.AssertHasNoTag(completedPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType);
+        AssertUtils.AssertHasNoTag(completedPoint.Value, WorkflowAttributes.AttributeWorkflowTriggerType);
     }
 
     [Fact]
@@ -291,13 +292,13 @@ public async Task Should_Record_All_Metrics_For_Multiple_Jobs()
         meterProvider.ForceFlush();
 
         // Assert - All metric types should be present
-        exportedItems.GetMetric(HangfireMetrics.ExecutionCountMetricName);
-        exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
-        exportedItems.GetMetric(HangfireMetrics.ExecutionStatusMetricName);
-        exportedItems.GetMetric(HangfireMetrics.WorkflowCountMetricName);
+        exportedItems.GetMetric(WorkflowMetricNames.ExecutionCount);
+        exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
+        exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
+        exportedItems.GetMetric(WorkflowMetricNames.WorkflowCount);
 
         // Verify execution.count has at least 3 executions
-        var executionCountMetric = exportedItems.First(m => m.Name == HangfireMetrics.ExecutionCountMetricName);
+        var executionCountMetric = exportedItems.First(m => m.Name == WorkflowMetricNames.ExecutionCount);
         var executionCountPoints = executionCountMetric.ToMetricPointList();
 
         var totalExecutions = executionCountPoints.Sum(mp => mp.GetSumLong());
@@ -325,11 +326,11 @@ public async Task Should_Use_Custom_DisplayName_For_Metrics()
         meterProvider.ForceFlush();
 
         // Assert
-        var executionCountMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionCountMetricName);
+        var executionCountMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionCount);
         AssertUtils.AssertHasMetricPoints(executionCountMetric);
 
         var metricPoint = executionCountMetric!.ToMetricPointList().First();
-        AssertUtils.AssertHasTagValue(metricPoint, HangfireTagBuilder.TagWorkflowTaskName, customName);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName, customName);
     }
 
     [Fact]
@@ -352,20 +353,20 @@ public async Task Should_Track_Success_And_Failure_Outcomes_Separately()
         meterProvider.ForceFlush();
 
         // Assert - Check execution duration metric has both outcomes
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
 
         var metricPoints = durationMetric!.ToMetricPointList();
 
         // Verify success outcome exists without error type
-        var successPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+        var successPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
         Assert.NotNull(successPoint);
-        AssertUtils.AssertHasNoTag(successPoint.Value, HangfireTagBuilder.TagErrorType);
+        AssertUtils.AssertHasNoTag(successPoint.Value, WorkflowAttributes.AttributeErrorType);
 
         // Verify failure outcome exists with error type
-        var failurePoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeFailure);
+        var failurePoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Failure);
         Assert.NotNull(failurePoint);
-        AssertUtils.AssertHasTag(failurePoint.Value, HangfireTagBuilder.TagErrorType);
+        AssertUtils.AssertHasTag(failurePoint.Value, WorkflowAttributes.AttributeErrorType);
     }
 
     [Fact]
@@ -387,17 +388,17 @@ public async Task Should_Record_TriggerType_Cron_For_Recurring_Jobs_On_Workflow_
         meterProvider.ForceFlush();
 
         // Assert - Check workflow.count metric has cron trigger type (NOT execution-level metrics)
-        var workflowCountMetric = exportedItems.GetMetric(HangfireMetrics.WorkflowCountMetricName);
+        var workflowCountMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowCount);
         AssertUtils.AssertHasMetricPoints(workflowCountMetric);
         var metricPoints = workflowCountMetric!.ToMetricPointList();
 
         // Find the workflow.count metric point
-        var workflowPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeCron);
+        var workflowPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Cron);
 
         Assert.NotNull(workflowPoint);
 
         // Verify trigger type is 'cron' for recurring jobs on workflow-level metric
-        AssertUtils.AssertHasTagValue(workflowPoint.Value, HangfireTagBuilder.TagWorkflowTriggerType, HangfireTagBuilder.TriggerTypeCron);
+        AssertUtils.AssertHasTagValue(workflowPoint.Value, WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Cron);
 
         // Cleanup
         RecurringJob.RemoveIfExists("test-recurring-job");
@@ -420,4 +421,146 @@ public void AddHangfireInstrumentation_Should_Register_Meter()
         // We don't need to wait for job completion, just verify the provider was configured
         Assert.NotNull(meterProvider);
     }
+
+    [Fact]
+    public async Task Should_Record_WorkflowStatus_For_Scheduled_Jobs()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Schedule a job for future execution
+        var jobId = BackgroundJob.Schedule<TestJob>(x => x.Execute(), TimeSpan.FromHours(1));
+
+        // Wait for job to reach scheduled state
+        await this.hangfireFixture.WaitJobInStateAsync(jobId, ScheduledState.StateName, 5);
+        meterProvider.ForceFlush();
+
+        // Assert - Scheduled jobs appear in workflow.status
+        var workflowStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowStatus);
+        AssertUtils.AssertHasMetricPoints(workflowStatusMetric);
+        Assert.Equal("{workflows}", workflowStatusMetric!.Unit);
+        Assert.Equal(MetricType.LongSumNonMonotonic, workflowStatusMetric.MetricType);
+
+        var metricPoints = workflowStatusMetric.ToMetricPointList();
+        var pendingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Pending);
+
+        Assert.NotNull(pendingPoint);
+        Assert.Equal(1, pendingPoint.Value.GetSumLong());
+
+        // Verify workflow-level tags (uses workflow.definition.name, workflow.state, workflow.trigger.type)
+        AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowDefinitionName);
+        AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowState);
+        AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowTriggerType);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Schedule);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Pending);
+
+        // Scheduled jobs should NOT appear in execution.status (haven't entered execution pipeline yet)
+        var executionStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
+        if (executionStatusMetric != null)
+        {
+            var execPoints = executionStatusMetric.ToMetricPointList();
+            // Should have no execution state metrics for scheduled jobs (not in execution pipeline)
+            var execPendingPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
+            Assert.Null(execPendingPoint);
+        }
+    }
+
+    [Fact]
+    public async Task Should_Track_Job_In_Both_Workflow_And_Execution_Metrics()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Schedule a job for immediate execution (1 second delay)
+        var jobId = BackgroundJob.Schedule<TestJob>(x => x.Execute(), TimeSpan.FromSeconds(1));
+
+        // Wait for job to complete full lifecycle
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 10);
+
+        meterProvider.ForceFlush();
+
+        // Assert - workflow.status should track full lifecycle (scheduled → enqueued → executing → completed)
+        var workflowStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowStatus);
+        AssertUtils.AssertHasMetricPoints(workflowStatusMetric);
+
+        var workflowPoints = workflowStatusMetric!.ToMetricPointList();
+
+        // Pending state transitions: +1 (scheduled) -1 (enqueued) +1 (enqueued) -1 (executing) = 0
+        var workflowPendingPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Pending);
+        if (workflowPendingPoint != null)
+        {
+            Assert.Equal(0, workflowPendingPoint.Value.GetSumLong());
+        }
+
+        // Final workflow state should be completed (+1)
+        var workflowCompletedPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Completed);
+        Assert.NotNull(workflowCompletedPoint);
+        Assert.Equal(1, workflowCompletedPoint.Value.GetSumLong());
+
+        // Assert - workflow.execution.status should also track lifecycle (enqueued → executing → completed)
+        // but NOT the scheduled phase
+        var executionStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
+        AssertUtils.AssertHasMetricPoints(executionStatusMetric);
+
+        var execPoints = executionStatusMetric!.ToMetricPointList();
+
+        // Execution pending: +1 (enqueued) -1 (executing) = 0
+        var execPendingPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
+        if (execPendingPoint != null)
+        {
+            Assert.Equal(0, execPendingPoint.Value.GetSumLong());
+        }
+
+        // Final execution state should be completed (+1)
+        var execCompletedPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
+        Assert.NotNull(execCompletedPoint);
+        Assert.Equal(1, execCompletedPoint.Value.GetSumLong());
+    }
+
+    [Fact]
+    public async Task Should_Track_FireAndForget_Job_In_Both_Metrics()
+    {
+        // Arrange
+        var exportedItems = new List<Metric>();
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddHangfireInstrumentation()
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        // Act - Fire-and-forget job (goes straight to enqueued, no scheduled phase)
+        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
+        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 10);
+
+        meterProvider.ForceFlush();
+
+        // Assert - Should appear in BOTH workflow.status AND workflow.execution.status
+        var workflowStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowStatus);
+        AssertUtils.AssertHasMetricPoints(workflowStatusMetric);
+
+        var workflowPoints = workflowStatusMetric!.ToMetricPointList();
+        var workflowCompletedPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Completed);
+        Assert.NotNull(workflowCompletedPoint);
+        Assert.Equal(1, workflowCompletedPoint.Value.GetSumLong());
+
+        // Also in execution.status
+        var executionStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
+        AssertUtils.AssertHasMetricPoints(executionStatusMetric);
+
+        var execPoints = executionStatusMetric!.ToMetricPointList();
+        var execCompletedPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
+        Assert.NotNull(execCompletedPoint);
+        Assert.Equal(1, execCompletedPoint.Value.GetSumLong());
+
+        // Verify workflow.status uses trigger.type=api for fire-and-forget
+        var apiTriggerPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Api);
+        Assert.NotNull(apiTriggerPoint);
+    }
 }
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
index 3048e20a06..205f50350c 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
@@ -36,7 +36,7 @@ public async Task Should_NOT_Record_PendingDuration_By_Default()
         meterProvider.ForceFlush();
 
         // Assert - workflow.execution.duration with state="pending" should NOT be present
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
 
         // Duration metric will exist (for state="executing"), but NOT for state="pending"
         Assert.NotNull(durationMetric);
@@ -45,8 +45,8 @@ public async Task Should_NOT_Record_PendingDuration_By_Default()
         // Ensure NO pending state metric point exists
         var pendingPoints = metricPoints.Where(mp =>
         {
-            var stateValue = mp.GetTagValue(HangfireTagBuilder.TagWorkflowExecutionState);
-            return stateValue != null && stateValue.Equals(HangfireTagBuilder.StatePending);
+            var stateValue = mp.GetTagValue(WorkflowAttributes.AttributeWorkflowExecutionState);
+            return stateValue != null && stateValue.Equals(WorkflowAttributes.WorkflowStateValues.Pending);
         }).ToList();
 
         Assert.Empty(pendingPoints);
@@ -72,7 +72,7 @@ public async Task Should_Record_PendingDuration_When_RecordQueueLatency_Enabled(
         meterProvider.ForceFlush();
 
         // Assert - workflow.execution.duration with state="pending" should be present
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
         Assert.Equal("s", durationMetric!.Unit);
         Assert.Equal(MetricType.Histogram, durationMetric.MetricType);
@@ -80,7 +80,7 @@ public async Task Should_Record_PendingDuration_When_RecordQueueLatency_Enabled(
         var metricPoints = durationMetric.ToMetricPointList();
 
         // Find the pending state metric point
-        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        var pendingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
         Assert.NotNull(pendingPoint);
 
         var count = pendingPoint.Value.GetHistogramCount();
@@ -90,10 +90,10 @@ public async Task Should_Record_PendingDuration_When_RecordQueueLatency_Enabled(
         Assert.True(sum >= 0, $"Expected histogram sum >= 0 for pending state, got {sum}");
 
         // Validate tags
-        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowTaskName);
-        AssertUtils.AssertHasTag(pendingPoint.Value, HangfireTagBuilder.TagWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
-        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+        AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowTaskName);
+        AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowPlatformName);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
     }
 
     [Fact]
@@ -116,7 +116,7 @@ public async Task Should_NOT_Record_PendingDuration_When_Explicitly_Disabled()
         meterProvider.ForceFlush();
 
         // Assert - workflow.execution.duration with state="pending" should NOT be present
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
 
         // Duration metric will exist (for state="executing"), but NOT for state="pending"
         Assert.NotNull(durationMetric);
@@ -125,8 +125,8 @@ public async Task Should_NOT_Record_PendingDuration_When_Explicitly_Disabled()
         // Ensure NO pending state metric point exists
         var pendingPoints = metricPoints.Where(mp =>
         {
-            var stateValue = mp.GetTagValue(HangfireTagBuilder.TagWorkflowExecutionState);
-            return stateValue != null && stateValue.Equals(HangfireTagBuilder.StatePending);
+            var stateValue = mp.GetTagValue(WorkflowAttributes.AttributeWorkflowExecutionState);
+            return stateValue != null && stateValue.Equals(WorkflowAttributes.WorkflowStateValues.Pending);
         }).ToList();
 
         Assert.Empty(pendingPoints);
@@ -152,18 +152,18 @@ public async Task Should_Record_Both_Pending_And_Executing_Duration_When_Enabled
         meterProvider.ForceFlush();
 
         // Assert - Both pending and executing durations should be recorded
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
 
         var metricPoints = durationMetric!.ToMetricPointList();
 
         // Verify pending state duration
-        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        var pendingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
         Assert.NotNull(pendingPoint);
         Assert.True(pendingPoint.Value.GetHistogramCount() >= 1);
 
         // Verify executing state duration
-        var executingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting);
+        var executingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing);
         Assert.NotNull(executingPoint);
         Assert.True(executingPoint.Value.GetHistogramCount() >= 1);
     }
@@ -188,22 +188,22 @@ public async Task Should_Record_PendingDuration_For_Failed_Job()
         meterProvider.ForceFlush();
 
         // Assert - Pending duration should be recorded even for failed jobs
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
 
         var metricPoints = durationMetric!.ToMetricPointList();
 
         // Find pending state metric point (should have success outcome since pending phase succeeded)
-        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        var pendingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
         Assert.NotNull(pendingPoint);
 
         // Pending phase should be successful (job started executing)
-        AssertUtils.AssertHasTagValue(pendingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeSuccess);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
 
         // Executing phase should have failure outcome
-        var executingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StateExecuting);
+        var executingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing);
         Assert.NotNull(executingPoint);
-        AssertUtils.AssertHasTagValue(executingPoint.Value, HangfireTagBuilder.TagWorkflowExecutionOutcome, HangfireTagBuilder.OutcomeFailure);
+        AssertUtils.AssertHasTagValue(executingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Failure);
     }
 
     [Fact]
@@ -231,13 +231,13 @@ public async Task Should_Record_PendingDuration_For_Multiple_Jobs()
         meterProvider.ForceFlush();
 
         // Assert - Pending duration should be recorded for all jobs
-        var durationMetric = exportedItems.GetMetric(HangfireMetrics.ExecutionDurationMetricName);
+        var durationMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         AssertUtils.AssertHasMetricPoints(durationMetric);
 
         var metricPoints = durationMetric!.ToMetricPointList();
 
         // Find pending state metric point
-        var pendingPoint = metricPoints.FindFirstWithTag(HangfireTagBuilder.TagWorkflowExecutionState, HangfireTagBuilder.StatePending);
+        var pendingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
         Assert.NotNull(pendingPoint);
 
         var count = pendingPoint.Value.GetHistogramCount();

From 96d8aa8b3499024eb72b7995cf79959d5057f51c Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Sat, 25 Oct 2025 10:06:09 -0400
Subject: [PATCH 05/48] Use job formatter from hangfire

---
 .../HangfireMetricsInstrumentationOptions.cs  |  9 ---
 .../HangfireMetricsErrorFilterAttribute.cs    |  1 -
 .../HangfireMetricsInstrumentation.cs         |  6 +-
 .../HangfireMetricsJobFilterAttribute.cs      | 13 ----
 .../HangfireMetricsStateFilter.cs             | 12 ----
 .../HangfirePendingDurationFilterAttribute.cs | 10 ---
 .../Implementation/HangfireTagBuilder.cs      | 48 +++++++-------
 .../Implementation/JobNameFormatter.cs        | 23 +++++++
 .../Implementation/TypeExtensions.cs          | 63 +++++++++++++++++++
 .../HangfireMetricsTests.cs                   | 28 ---------
 10 files changed, 112 insertions(+), 101 deletions(-)
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs
 create mode 100644 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
index 941410c926..9c038c58c3 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
@@ -21,13 +21,4 @@ public sealed class HangfireMetricsInstrumentationOptions
     /// When disabled, only execution duration (state="executing") is recorded.
     /// </remarks>
     public bool RecordQueueLatency { get; set; }
-
-    /// <summary>
-    /// Gets or sets a delegate used to format the job name for metrics.
-    /// </summary>
-    /// <remarks>
-    /// Defaults to <c>backgroundJob.Job.ToString()</c>.
-    /// </remarks>
-    public Func<BackgroundJob, string> DisplayNameFunc { get; set; } =
-        backgroundJob => backgroundJob.Job?.ToString() ?? "unknown";
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
index 5b67566382..f3116dd8fb 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
@@ -32,7 +32,6 @@ public void OnPerformed(PerformedContext performedContext)
         {
             var errorTags = HangfireTagBuilder.BuildErrorTags(
                 performedContext.BackgroundJob,
-                this.options.DisplayNameFunc,
                 performedContext.Exception);
 
             HangfireMetrics.ExecutionErrors.Add(1, errorTags);
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
index 87faaa2194..47b52cc884 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
@@ -15,14 +15,14 @@ internal sealed class HangfireMetricsInstrumentation : IDisposable
 
     public HangfireMetricsInstrumentation(HangfireMetricsInstrumentationOptions options)
     {
-        this.AddFilter(new HangfireMetricsJobFilterAttribute(options));
-        this.AddFilter(new HangfireMetricsStateFilter(options));
+        this.AddFilter(new HangfireMetricsJobFilterAttribute());
+        this.AddFilter(new HangfireMetricsStateFilter());
         this.AddFilter(new HangfireMetricsErrorFilterAttribute(options));
 
         // Only register pending duration filter if enabled (requires DB call per job)
         if (options.RecordQueueLatency)
         {
-            this.AddFilter(new HangfirePendingDurationFilterAttribute(options));
+            this.AddFilter(new HangfirePendingDurationFilterAttribute());
         }
     }
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
index ba0684424b..8a20e926b2 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
@@ -4,7 +4,6 @@
 using System.Diagnostics;
 using Hangfire.Common;
 using Hangfire.Server;
-using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
@@ -14,14 +13,6 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 internal sealed class HangfireMetricsJobFilterAttribute : JobFilterAttribute, IServerFilter
 {
     private const string StopwatchKey = "OpenTelemetry.Metrics.Stopwatch";
-    private readonly HangfireMetricsInstrumentationOptions options;
-
-#pragma warning disable CA1019 // Define accessors for attribute arguments
-    public HangfireMetricsJobFilterAttribute(HangfireMetricsInstrumentationOptions options)
-#pragma warning restore CA1019 // Define accessors for attribute arguments
-    {
-        this.options = options ?? throw new ArgumentNullException(nameof(options));
-    }
 
     public void OnPerforming(PerformingContext performingContext)
     {
@@ -44,12 +35,10 @@ public void OnPerformed(PerformedContext performedContext)
         }
 
         var backgroundJob = performedContext.BackgroundJob;
-        var displayNameFunc = this.options.DisplayNameFunc;
 
         // Record execution count (without state attribute per semantic conventions)
         var countTags = HangfireTagBuilder.BuildExecutionCountTags(
             backgroundJob,
-            displayNameFunc,
             performedContext.Exception);
 
         HangfireMetrics.ExecutionCount.Add(1, countTags);
@@ -62,7 +51,6 @@ public void OnPerformed(PerformedContext performedContext)
 
             var durationTags = HangfireTagBuilder.BuildExecutionTags(
                 backgroundJob,
-                displayNameFunc,
                 performedContext.Exception,
                 workflowState: WorkflowAttributes.WorkflowStateValues.Executing);
 
@@ -72,7 +60,6 @@ public void OnPerformed(PerformedContext performedContext)
         // Record workflow-level metrics (includes trigger type)
         var workflowTags = HangfireTagBuilder.BuildWorkflowTags(
             backgroundJob,
-            displayNameFunc,
             performedContext.Exception,
             recurringJobId);
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index 42dc3514b3..631a3696be 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -4,7 +4,6 @@
 using Hangfire.Common;
 using Hangfire.States;
 using Hangfire.Storage;
-using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
@@ -75,15 +74,6 @@ private enum StateTransitionDirection
         }
     }
 
-    private readonly HangfireMetricsInstrumentationOptions options;
-
-#pragma warning disable CA1019 // Define accessors for attribute arguments
-    public HangfireMetricsStateFilter(HangfireMetricsInstrumentationOptions options)
-#pragma warning restore CA1019 // Define accessors for attribute arguments
-    {
-        this.options = options ?? throw new ArgumentNullException(nameof(options));
-    }
-
     public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
     {
         this.RecordWorkflowStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Applied);
@@ -121,7 +111,6 @@ private void RecordWorkflowStateChange(
 
         var tags = HangfireTagBuilder.BuildWorkflowStatusTags(
             context.BackgroundJob,
-            this.options.DisplayNameFunc,
             stateToRecord,
             recurringJobId,
             errorType);
@@ -154,7 +143,6 @@ private void RecordExecutionStateChange(
 
         var tags = HangfireTagBuilder.BuildExecutionstatusTags(
             context.BackgroundJob,
-            this.options.DisplayNameFunc,
             stateToRecord,
             errorType);
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
index 73d1a9ce6d..fb913934de 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfirePendingDurationFilterAttribute.cs
@@ -4,7 +4,6 @@
 using Hangfire.Common;
 using Hangfire.Server;
 using Hangfire.States;
-using OpenTelemetry.Metrics;
 using DateTime = System.DateTime;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
@@ -20,14 +19,6 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 internal sealed class HangfirePendingDurationFilterAttribute : JobFilterAttribute, IServerFilter, IElectStateFilter
 {
     private const string EnqueuedAtParameter = "OpenTelemetry.EnqueuedAt";
-    private readonly HangfireMetricsInstrumentationOptions options;
-
-#pragma warning disable CA1019 // Define accessors for attribute arguments
-    public HangfirePendingDurationFilterAttribute(HangfireMetricsInstrumentationOptions options)
-#pragma warning restore CA1019 // Define accessors for attribute arguments
-    {
-        this.options = options ?? throw new ArgumentNullException(nameof(options));
-    }
 
     public void OnStateElection(ElectStateContext context)
     {
@@ -67,7 +58,6 @@ public void OnPerforming(PerformingContext performingContext)
                 // Record workflow.execution.duration with state="pending"
                 var tags = HangfireTagBuilder.BuildExecutionTags(
                     performingContext.BackgroundJob,
-                    this.options.DisplayNameFunc,
                     exception: null,
                     workflowState: WorkflowAttributes.WorkflowStateValues.Pending);
                 HangfireMetrics.ExecutionDuration.Record(pendingDuration, tags);
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index 4328f97046..3d506c5cd4 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -19,13 +19,13 @@ internal static class HangfireTagBuilder
     /// Includes required workflow.task.name and recommended workflow.platform.name.
     /// Also includes custom Hangfire-specific attributes (job.type, job.method).
     /// </summary>
-    /// <param name="job">The Hangfire job.</param>
+    /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <returns>Tag list with common job tags.</returns>
-    public static TagList BuildCommonTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc)
+    public static TagList BuildCommonTags(BackgroundJob backgroundJob)
     {
         var tags = new TagList
         {
-            GetTaskName(backgroundJob, displayNameFunc),
+            GetTaskName(backgroundJob),
             GetPlatformName(),
         };
         return tags;
@@ -37,15 +37,15 @@ public static TagList BuildCommonTags(BackgroundJob backgroundJob, Func<Backgrou
     /// recommended workflow.platform.name, and conditionally required error.type.
     /// Note: workflow.trigger.type is NOT included as it belongs to workflow-level metrics only.
     /// </summary>
-    /// <param name="job">The Hangfire job.</param>
+    /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <param name="workflowState">The workflow state value.</param>
     /// <param name="errorType">Optional error type to annotate failure states.</param>
     /// <returns>Tag list suitable for workflow.execution.status metric.</returns>
-    public static TagList BuildExecutionstatusTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, string workflowState, string? errorType)
+    public static TagList BuildExecutionstatusTags(BackgroundJob backgroundJob, string workflowState, string? errorType)
     {
         var tags = new TagList
         {
-            GetTaskName(backgroundJob, displayNameFunc),
+            GetTaskName(backgroundJob),
             GetPlatformName(),
             GetState(workflowState),
         };
@@ -66,15 +66,15 @@ public static TagList BuildExecutionstatusTags(BackgroundJob backgroundJob, Func
     /// conditionally required attributes (error.type if failed).
     /// Note: workflow.trigger.type is NOT included as it belongs to workflow-level metrics only.
     /// </summary>
-    /// <param name="job">The Hangfire job.</param>
+    /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <param name="exception">The exception, if any occurred.</param>
     /// <param name="workflowState">The workflow state value (typically "executing" for execution duration).</param>
     /// <returns>Tag list with execution result tags.</returns>
-    public static TagList BuildExecutionTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, Exception? exception, string workflowState)
+    public static TagList BuildExecutionTags(BackgroundJob backgroundJob, Exception? exception, string workflowState)
     {
         var tags = new TagList
         {
-            GetTaskName(backgroundJob, displayNameFunc),
+            GetTaskName(backgroundJob),
             GetPlatformName(),
             GetExecutionOutcome(exception),
             GetState(workflowState),
@@ -96,14 +96,14 @@ public static TagList BuildExecutionTags(BackgroundJob backgroundJob, Func<Backg
     /// conditionally required attributes (error.type if failed).
     /// Note: Does NOT include workflow.execution.state as it's not specified in semantic conventions for count metric.
     /// </summary>
-    /// <param name="job">The Hangfire job.</param>
+    /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <param name="exception">The exception, if any occurred.</param>
     /// <returns>Tag list suitable for workflow.execution.count metric.</returns>
-    public static TagList BuildExecutionCountTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, Exception? exception)
+    public static TagList BuildExecutionCountTags(BackgroundJob backgroundJob, Exception? exception)
     {
         var tags = new TagList
         {
-            GetTaskName(backgroundJob, displayNameFunc),
+            GetTaskName(backgroundJob),
             GetPlatformName(),
             GetExecutionOutcome(exception),
         };
@@ -124,15 +124,15 @@ public static TagList BuildExecutionCountTags(BackgroundJob backgroundJob, Func<
     /// conditionally required attributes (error.type if failed).
     /// Used for workflow.count and other workflow-level (not execution-level) metrics.
     /// </summary>
-    /// <param name="job">The Hangfire job.</param>
+    /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <param name="exception">The exception, if any occurred.</param>
     /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
     /// <returns>Tag list suitable for workflow.count metric.</returns>
-    public static TagList BuildWorkflowTags(BackgroundJob job, Func<BackgroundJob, string> displayNameFunc, Exception? exception, string? recurringJobId)
+    public static TagList BuildWorkflowTags(BackgroundJob backgroundJob, Exception? exception, string? recurringJobId)
     {
         var tags = new TagList
         {
-            GetDefinitionName(job, displayNameFunc),
+            GetDefinitionName(backgroundJob),
             GetPlatformName(),
             GetWorkflowOutcome(exception),
             GetTriggerType(recurringJobId),
@@ -155,21 +155,19 @@ public static TagList BuildWorkflowTags(BackgroundJob job, Func<BackgroundJob, s
     /// Used for tracking workflow state transitions (e.g., scheduled jobs).
     /// </summary>
     /// <param name="backgroundJob">The Hangfire background job.</param>
-    /// <param name="displayNameFunc">Function to generate display name.</param>
     /// <param name="workflowState">The workflow state value (e.g., "pending", "executing", "completed").</param>
     /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
     /// <param name="errorType">Optional error type to annotate failure states.</param>
     /// <returns>Tag list suitable for workflow.status metric.</returns>
     public static TagList BuildWorkflowStatusTags(
         BackgroundJob backgroundJob,
-        Func<BackgroundJob, string> displayNameFunc,
         string workflowState,
         string? recurringJobId,
         string? errorType)
     {
         var tags = new TagList
         {
-            GetDefinitionName(backgroundJob, displayNameFunc),
+            GetDefinitionName(backgroundJob),
             GetPlatformName(),
             new KeyValuePair<string, object?>(WorkflowAttributes.AttributeWorkflowState, workflowState),
             GetTriggerType(recurringJobId, isScheduled: workflowState == WorkflowAttributes.WorkflowStateValues.Pending && string.IsNullOrEmpty(recurringJobId)),
@@ -188,15 +186,15 @@ public static TagList BuildWorkflowStatusTags(
     /// Includes required attributes (error.type, workflow.task.name),
     /// recommended attributes (workflow.platform.name).
     /// </summary>
-    /// <param name="job">The Hangfire job.</param>
+    /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <param name="exception">The exception that occurred.</param>
     /// <returns>Tag list with error tags.</returns>
-    public static TagList BuildErrorTags(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc, Exception exception)
+    public static TagList BuildErrorTags(BackgroundJob backgroundJob, Exception exception)
     {
         var tags = new TagList
         {
             GetErrorType(exception),
-            GetTaskName(backgroundJob, displayNameFunc),
+            GetTaskName(backgroundJob),
             GetPlatformName(),
         };
 
@@ -204,11 +202,11 @@ public static TagList BuildErrorTags(BackgroundJob backgroundJob, Func<Backgroun
     }
 
     // Required workflow attributes
-    private static KeyValuePair<string, object?> GetTaskName(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc) =>
-        new(WorkflowAttributes.AttributeWorkflowTaskName, displayNameFunc(backgroundJob));
+    private static KeyValuePair<string, object?> GetTaskName(BackgroundJob backgroundJob) =>
+        new(WorkflowAttributes.AttributeWorkflowTaskName, backgroundJob.FormatJobName());
 
-    private static KeyValuePair<string, object?> GetDefinitionName(BackgroundJob backgroundJob, Func<BackgroundJob, string> displayNameFunc) =>
-        new(WorkflowAttributes.AttributeWorkflowDefinitionName, displayNameFunc(backgroundJob));
+    private static KeyValuePair<string, object?> GetDefinitionName(BackgroundJob backgroundJob) =>
+        new(WorkflowAttributes.AttributeWorkflowDefinitionName, backgroundJob.FormatJobName());
 
     private static KeyValuePair<string, object?> GetExecutionOutcome(Exception? exception) =>
         new(WorkflowAttributes.AttributeWorkflowExecutionOutcome, exception is null ? WorkflowAttributes.WorkflowOutcomeValues.Success : WorkflowAttributes.WorkflowOutcomeValues.Failure);
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs
new file mode 100644
index 0000000000..29bf42b5c3
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs
@@ -0,0 +1,23 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Text;
+using Hangfire;
+using Hangfire.Common;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+internal static class JobNameFormatter
+{
+    internal static string FormatJobName(this Job job)
+    {
+        var sb = new StringBuilder()
+            .Append(job.Type.ToGenericTypeString())
+            .Append('.')
+            .Append(job.Method.Name);
+
+        return sb.ToString();
+    }
+
+    internal static string FormatJobName(this BackgroundJob backgroundJob) => backgroundJob.Job.FormatJobName();
+}
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
new file mode 100644
index 0000000000..448aef1f9b
--- /dev/null
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
@@ -0,0 +1,63 @@
+using System.Globalization;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
+
+    internal static class TypeExtensions
+    {
+        private static readonly Regex GenericArgumentsRegex = new Regex(@"`[1-9]\d*", RegexOptions.Compiled, TimeSpan.FromSeconds(5));
+
+        public static string ToGenericTypeString(this Type type)
+        {
+            if (!type.GetTypeInfo().IsGenericType)
+            {
+                return type.GetFullNameWithoutNamespace()
+                        .ReplacePlusWithDotInNestedTypeName();
+            }
+
+            return type.GetGenericTypeDefinition()
+                    .GetFullNameWithoutNamespace()
+                    .ReplacePlusWithDotInNestedTypeName()
+                    .ReplaceGenericParametersInGenericTypeName(type);
+        }
+
+        public static Type[] GetAllGenericArguments(this TypeInfo type)
+        {
+            return type.GenericTypeArguments.Length > 0 ? type.GenericTypeArguments : type.GenericTypeParameters;
+        }
+
+        private static string GetFullNameWithoutNamespace(this Type type)
+        {
+            if (type.IsGenericParameter)
+            {
+                return type.Name;
+            }
+
+            const int dotLength = 1;
+            // ReSharper disable once PossibleNullReferenceException
+            return !String.IsNullOrEmpty(type.Namespace)
+                ? type.FullName.Substring(type.Namespace.Length + dotLength)
+                : type.FullName;
+        }
+
+        private static string ReplacePlusWithDotInNestedTypeName(this string typeName)
+        {
+            return typeName.Replace('+', '.');
+        }
+
+        private static string ReplaceGenericParametersInGenericTypeName(this string typeName, Type type)
+        {
+            var genericArguments = type.GetTypeInfo().GetAllGenericArguments();
+
+            typeName = GenericArgumentsRegex.Replace(typeName, match =>
+            {
+                var currentGenericArgumentNumbers = int.Parse(match.Value.Substring(1), CultureInfo.InvariantCulture);
+                var currentArguments = string.Join(",", genericArguments.Take(currentGenericArgumentNumbers).Select(ToGenericTypeString));
+                genericArguments = genericArguments.Skip(currentGenericArgumentNumbers).ToArray();
+                return string.Concat("<", currentArguments, ">");
+            });
+
+            return typeName;
+        }
+    }
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index 6b866ee9a1..788cf45c81 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -305,34 +305,6 @@ public async Task Should_Record_All_Metrics_For_Multiple_Jobs()
         Assert.True(totalExecutions >= 3, $"Expected at least 3 executions, got {totalExecutions}");
     }
 
-    [Fact]
-    public async Task Should_Use_Custom_DisplayName_For_Metrics()
-    {
-        // Arrange
-        const string customName = "CustomJobName";
-        var exportedItems = new List<Metric>();
-        using var meterProvider = Sdk.CreateMeterProviderBuilder()
-            .AddHangfireInstrumentation(options =>
-            {
-                options.DisplayNameFunc = _ => customName;
-            })
-            .AddInMemoryExporter(exportedItems)
-            .Build();
-
-        // Act
-        var jobId = BackgroundJob.Enqueue<TestJob>(x => x.Execute());
-        await this.hangfireFixture.WaitJobProcessedAsync(jobId, 5);
-
-        meterProvider.ForceFlush();
-
-        // Assert
-        var executionCountMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionCount);
-        AssertUtils.AssertHasMetricPoints(executionCountMetric);
-
-        var metricPoint = executionCountMetric!.ToMetricPointList().First();
-        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName, customName);
-    }
-
     [Fact]
     public async Task Should_Track_Success_And_Failure_Outcomes_Separately()
     {

From 742b2a067419d0e20e57f9155aef3f48ff78a65b Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Sat, 25 Oct 2025 10:22:21 -0400
Subject: [PATCH 06/48] Fix tests

---
 .../HangfireFixture.cs                                   | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
index 26ecd97a52..f66d65eff7 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
@@ -3,6 +3,7 @@
 
 using Hangfire;
 using Hangfire.MemoryStorage;
+using Hangfire.States;
 using Hangfire.Storage;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
@@ -31,17 +32,17 @@ public HangfireFixture()
     public IMonitoringApi MonitoringApi { get; }
 
     /// <summary>
-    /// Waits for a Hangfire job to be processed (complete processing state).
+    /// Waits for a Hangfire job to be processed (reach a terminal state).
     /// </summary>
     /// <param name="jobId">The ID of the job to wait for.</param>
     /// <param name="timeToWaitInSeconds">Maximum time to wait in seconds.</param>
-    /// <returns>A task that completes when the job is processed or the timeout expires.</returns>
+    /// <returns>A task that completes when the job reaches a terminal state or the timeout expires.</returns>
     public async Task WaitJobProcessedAsync(string jobId, int timeToWaitInSeconds)
     {
         var timeout = TimeSpan.FromSeconds(timeToWaitInSeconds);
         using var cts = new CancellationTokenSource(timeout);
 
-        string[] states = ["Enqueued", "Processing"];
+        string[] terminalStates = [SucceededState.StateName, FailedState.StateName, DeletedState.StateName];
 
         while (!Completed() && !cts.IsCancellationRequested)
         {
@@ -60,7 +61,7 @@ bool Completed()
             // Copy the history to an array to avoid exception if the collection is modified while iterating
             var history = jobDetails.History.ToArray();
 
-            return !history.All(h => states.Contains(h.StateName));
+            return history.Any(h => terminalStates.Contains(h.StateName));
         }
     }
 

From aa3ac32bba92d0a61774e469a1e58463259f347c Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Sat, 25 Oct 2025 10:49:30 -0400
Subject: [PATCH 07/48] Fix and speed up tests

---
 .../HangfireFixture.cs                          | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
index f66d65eff7..9535e71595 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
@@ -5,6 +5,7 @@
 using Hangfire.MemoryStorage;
 using Hangfire.States;
 using Hangfire.Storage;
+using Xunit;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
 
@@ -23,7 +24,14 @@ public HangfireFixture()
             GlobalJobFilters.Filters.Remove(retryFilter.Instance);
         }
 
-        this.Server = new BackgroundJobServer();
+        // Configure server with faster schedule polling for tests
+        // Default is 15 seconds, which is too slow for test scenarios
+        var options = new BackgroundJobServerOptions
+        {
+            SchedulePollingInterval = TimeSpan.FromMilliseconds(100)
+        };
+
+        this.Server = new BackgroundJobServer(options);
         this.MonitoringApi = JobStorage.Current.GetMonitoringApi();
     }
 
@@ -44,11 +52,14 @@ public async Task WaitJobProcessedAsync(string jobId, int timeToWaitInSeconds)
 
         string[] terminalStates = [SucceededState.StateName, FailedState.StateName, DeletedState.StateName];
 
-        while (!Completed() && !cts.IsCancellationRequested)
+        while (!cts.IsCancellationRequested)
         {
-            await Task.Delay(500);
+            if (Completed()) return;
+            await Task.Delay(50, cts.Token);
         }
 
+        Assert.Fail("Timeout");
+
         bool Completed()
         {
             var jobDetails = this.MonitoringApi.JobDetails(jobId);

From 1f909bdecce2aff74cb2976c4cc3eb8ffdde93ca Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:45:10 -0400
Subject: [PATCH 08/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../HangfireMetricsErrorFilterAttribute.cs               | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
index f3116dd8fb..8f998b4ee6 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
@@ -13,15 +13,6 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal sealed class HangfireMetricsErrorFilterAttribute : JobFilterAttribute, IServerFilter
 {
-    private readonly HangfireMetricsInstrumentationOptions options;
-
-#pragma warning disable CA1019 // Define accessors for attribute arguments
-    public HangfireMetricsErrorFilterAttribute(HangfireMetricsInstrumentationOptions options)
-#pragma warning restore CA1019 // Define accessors for attribute arguments
-    {
-        this.options = options ?? throw new ArgumentNullException(nameof(options));
-    }
-
     public void OnPerforming(PerformingContext performingContext)
     {
     }

From 42476f8f76e7f20f0770889df4fd7305c972a05b Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:45:29 -0400
Subject: [PATCH 09/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireMetricsInstrumentation.cs            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
index 47b52cc884..b8231f70fa 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsInstrumentation.cs
@@ -17,7 +17,7 @@ public HangfireMetricsInstrumentation(HangfireMetricsInstrumentationOptions opti
     {
         this.AddFilter(new HangfireMetricsJobFilterAttribute());
         this.AddFilter(new HangfireMetricsStateFilter());
-        this.AddFilter(new HangfireMetricsErrorFilterAttribute(options));
+        this.AddFilter(new HangfireMetricsErrorFilterAttribute());
 
         // Only register pending duration filter if enabled (requires DB call per job)
         if (options.RecordQueueLatency)

From accd8bc0f1b0d3e34db9899e644149e55409e993 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:45:47 -0400
Subject: [PATCH 10/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireMetricsStateFilter.cs              | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index 631a3696be..726cac9089 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -76,8 +76,8 @@ private enum StateTransitionDirection
 
     public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
     {
-        this.RecordWorkflowStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Applied);
-        this.RecordExecutionStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Applied);
+        this.RecordWorkflowStateChange(context, StateTransitionDirection.Applied);
+        this.RecordExecutionStateChange(context, StateTransitionDirection.Applied);
     }
 
     public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction)

From 302542aa4962868aca457bc23a97ad7bfe933aeb Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:45:56 -0400
Subject: [PATCH 11/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireMetricsStateFilter.cs              | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index 726cac9089..b577815de7 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -82,8 +82,8 @@ public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction tran
 
     public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
     {
-        this.RecordWorkflowStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Unapplied);
-        this.RecordExecutionStateChange(context, context.OldStateName, context.NewState.Name, StateTransitionDirection.Unapplied);
+        this.RecordWorkflowStateChange(context, StateTransitionDirection.Unapplied);
+        this.RecordExecutionStateChange(context, StateTransitionDirection.Unapplied);
     }
 
     private void RecordWorkflowStateChange(

From 5af844c3bac5ac1b50e38d3d54ee938adeab8959 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:46:40 -0400
Subject: [PATCH 12/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireTagBuilder.cs                      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index 3d506c5cd4..9adc6b1453 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -214,7 +214,7 @@ public static TagList BuildErrorTags(BackgroundJob backgroundJob, Exception exce
     private static KeyValuePair<string, object?> GetWorkflowOutcome(Exception? exception) =>
         new(WorkflowAttributes.AttributeWorkflowOutcome, exception is null ? WorkflowAttributes.WorkflowOutcomeValues.Success : WorkflowAttributes.WorkflowOutcomeValues.Failure);
 
-    private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId, bool isScheduled = false)
+    private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId, WorkflowAttributes.WorkflowStateValues? workflowState = null)
     {
         // Check if job was triggered by a recurring job (cron)
         if (!string.IsNullOrEmpty(recurringJobId))
@@ -223,7 +223,7 @@ public static TagList BuildErrorTags(BackgroundJob backgroundJob, Exception exce
         }
 
         // Check if job is scheduled for future execution
-        if (isScheduled)
+        if (workflowState == WorkflowAttributes.WorkflowStateValues.Pending)
         {
             return new(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Schedule);
         }

From eae641c5753106d0e117d8b299dc4112341c7541 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:47:02 -0400
Subject: [PATCH 13/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireMetricsStateFilter.cs            | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index b577815de7..4c0a07468a 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -88,12 +88,10 @@ public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction tr
 
     private void RecordWorkflowStateChange(
         ApplyStateContext context,
-        string? oldStateName,
-        string? newStateName,
         StateTransitionDirection direction)
     {
-        var oldState = HangfireStateMapper.MapWorkflowState(oldStateName);
-        var newState = HangfireStateMapper.MapWorkflowState(newStateName);
+        var oldState = HangfireStateMapper.MapWorkflowState(context.OldStateName);
+        var newState = HangfireStateMapper.MapWorkflowState(context.NewState.Name);
 
         // Determine which state to record based on transition direction
         var stateToRecord = direction == StateTransitionDirection.Applied ? newState : oldState;

From 38883b80b6eee185ee3a790da11f4abfa57dac18 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:47:12 -0400
Subject: [PATCH 14/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireMetricsErrorFilterAttribute.cs     | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
index 8f998b4ee6..ca07844672 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
@@ -21,9 +21,7 @@ public void OnPerformed(PerformedContext performedContext)
     {
         if (performedContext.Exception != null)
         {
-            var errorTags = HangfireTagBuilder.BuildErrorTags(
-                performedContext.BackgroundJob,
-                performedContext.Exception);
+            var errorTags = HangfireTagBuilder.BuildErrorTags(performedContext);
 
             HangfireMetrics.ExecutionErrors.Add(1, errorTags);
         }

From 2e7cdff852ce38d4ee8504346fce0154478cd1ac Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:47:19 -0400
Subject: [PATCH 15/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireTagBuilder.cs                        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index 9adc6b1453..b280982d77 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -170,7 +170,7 @@ public static TagList BuildWorkflowStatusTags(
             GetDefinitionName(backgroundJob),
             GetPlatformName(),
             new KeyValuePair<string, object?>(WorkflowAttributes.AttributeWorkflowState, workflowState),
-            GetTriggerType(recurringJobId, isScheduled: workflowState == WorkflowAttributes.WorkflowStateValues.Pending && string.IsNullOrEmpty(recurringJobId)),
+            GetTriggerType(recurringJobId, workflowState),
         };
 
         if (!string.IsNullOrEmpty(errorType))

From 3254ed2ba24a21ed03eccaa1f5c80a1082415c97 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 08:47:33 -0400
Subject: [PATCH 16/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../Implementation/HangfireMetricsStateFilter.cs            | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index 4c0a07468a..e670223718 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -119,12 +119,10 @@ private void RecordWorkflowStateChange(
 
     private void RecordExecutionStateChange(
         ApplyStateContext context,
-        string? oldStateName,
-        string? newStateName,
         StateTransitionDirection direction)
     {
-        var oldState = HangfireStateMapper.MapExecutionState(oldStateName);
-        var newState = HangfireStateMapper.MapExecutionState(newStateName);
+        var oldState = HangfireStateMapper.MapExecutionState(context.OldStateName);
+        var newState = HangfireStateMapper.MapExecutionState(context.NewState.Name);
 
         // Determine which state to record based on transition direction
         var stateToRecord = direction == StateTransitionDirection.Applied ? newState : oldState;

From 693d1be21690b466066250afa8ed56349c145e28 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 09:01:55 -0400
Subject: [PATCH 17/48] build fix

---
 .../Implementation/HangfireTagBuilder.cs             | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index b280982d77..842f25db3a 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -13,7 +13,6 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal static class HangfireTagBuilder
 {
-
     /// <summary>
     /// Creates a tag list with common job metadata following workflow semantic conventions.
     /// Includes required workflow.task.name and recommended workflow.platform.name.
@@ -186,15 +185,14 @@ public static TagList BuildWorkflowStatusTags(
     /// Includes required attributes (error.type, workflow.task.name),
     /// recommended attributes (workflow.platform.name).
     /// </summary>
-    /// <param name="backgroundJob">The Hangfire background job.</param>
-    /// <param name="exception">The exception that occurred.</param>
+    /// <param name="performedContext">The Hangfire context.</param>
     /// <returns>Tag list with error tags.</returns>
-    public static TagList BuildErrorTags(BackgroundJob backgroundJob, Exception exception)
+    public static TagList BuildErrorTags(PerformedContext performedContext)
     {
         var tags = new TagList
         {
-            GetErrorType(exception),
-            GetTaskName(backgroundJob),
+            GetErrorType(performedContext.Exception),
+            GetTaskName(performedContext.BackgroundJob),
             GetPlatformName(),
         };
 
@@ -214,7 +212,7 @@ public static TagList BuildErrorTags(BackgroundJob backgroundJob, Exception exce
     private static KeyValuePair<string, object?> GetWorkflowOutcome(Exception? exception) =>
         new(WorkflowAttributes.AttributeWorkflowOutcome, exception is null ? WorkflowAttributes.WorkflowOutcomeValues.Success : WorkflowAttributes.WorkflowOutcomeValues.Failure);
 
-    private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId, WorkflowAttributes.WorkflowStateValues? workflowState = null)
+    private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId, string? workflowState = null)
     {
         // Check if job was triggered by a recurring job (cron)
         if (!string.IsNullOrEmpty(recurringJobId))

From 044e5005c1de69c09fada60821138d018137942a Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 10:26:44 -0400
Subject: [PATCH 18/48] Rename metrics/attributes

---
 .../Implementation/HangfireMetrics.cs         |   8 +-
 .../HangfireMetricsJobFilterAttribute.cs      |   6 +-
 .../Implementation/HangfireStateMapper.cs     |  20 ++-
 .../Implementation/HangfireTagBuilder.cs      |  32 ++---
 .../Implementation/WorkflowAttributes.cs      |  15 +--
 .../Implementation/WorkflowMetricNames.cs     |   4 +-
 .../README.md                                 |  22 +--
 .../HangfireMetricsTests.cs                   | 125 +++++++++---------
 .../HangfireQueueLatencyTests.cs              |   8 +-
 9 files changed, 119 insertions(+), 121 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
index b5cef73887..ccf864bea5 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
@@ -27,9 +27,9 @@ internal static class HangfireMetrics
     /// Counter for the number of task executions which have been initiated.
     /// Follows OpenTelemetry workflow semantic conventions.
     /// </summary>
-    public static readonly Counter<long> ExecutionCount =
+    public static readonly Counter<long> ExecutionOutcome =
         Meter.CreateCounter<long>(
-            WorkflowMetricNames.ExecutionCount,
+            WorkflowMetricNames.ExecutionOutcome,
             unit: "{executions}",
             description: "The number of task executions which have been initiated.");
 
@@ -71,9 +71,9 @@ internal static class HangfireMetrics
     /// Follows OpenTelemetry workflow semantic conventions.
     /// In Hangfire, this tracks individual job completions. For batch workflows, this would track batch completion.
     /// </summary>
-    public static readonly Counter<long> WorkflowCount =
+    public static readonly Counter<long> WorkflowOutcome =
         Meter.CreateCounter<long>(
-            WorkflowMetricNames.WorkflowCount,
+            WorkflowMetricNames.WorkflowOutcome,
             unit: "{workflows}",
             description: "The number of workflow instances which have been initiated.");
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
index 8a20e926b2..3797f4a213 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsJobFilterAttribute.cs
@@ -36,12 +36,12 @@ public void OnPerformed(PerformedContext performedContext)
 
         var backgroundJob = performedContext.BackgroundJob;
 
-        // Record execution count (without state attribute per semantic conventions)
+        // Record execution outcome (without state attribute per semantic conventions)
         var countTags = HangfireTagBuilder.BuildExecutionCountTags(
             backgroundJob,
             performedContext.Exception);
 
-        HangfireMetrics.ExecutionCount.Add(1, countTags);
+        HangfireMetrics.ExecutionOutcome.Add(1, countTags);
 
         // Record execution duration (with state="executing" to differentiate from pending phase)
         if (performedContext.Items.TryGetValue(StopwatchKey, out var stopwatchObj) && stopwatchObj is Stopwatch stopwatch)
@@ -63,6 +63,6 @@ public void OnPerformed(PerformedContext performedContext)
             performedContext.Exception,
             recurringJobId);
 
-        HangfireMetrics.WorkflowCount.Add(1, workflowTags);
+        HangfireMetrics.WorkflowOutcome.Add(1, workflowTags);
     }
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs
index 57843276d3..94fefc6610 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireStateMapper.cs
@@ -14,9 +14,11 @@ internal static class HangfireStateMapper
     /// Maps Hangfire state names to workflow execution semantic convention state values.
     /// Note: ScheduledState is NOT mapped here as it represents a workflow-level state,
     /// not an execution-level state. Use MapWorkflowState() for scheduled jobs.
+    /// Final states (Succeeded, Failed, Deleted) are not tracked in the status metric
+    /// as they represent terminal states that no longer transition.
     /// </summary>
     /// <param name="hangfireState">Hangfire state name.</param>
-    /// <returns>Mapped workflow execution state value, or <see langword="null"/> if the state is not recognized.</returns>
+    /// <returns>Mapped workflow execution state value, or <see langword="null"/> if the state is not recognized or is a final state.</returns>
     public static string? MapExecutionState(string? hangfireState)
     {
         if (hangfireState == EnqueuedState.StateName ||
@@ -30,11 +32,13 @@ internal static class HangfireStateMapper
             return WorkflowAttributes.WorkflowStateValues.Executing;
         }
 
+        // Final states (Succeeded, Failed, Deleted) are not tracked in status metric
+        // as they represent terminal states where no further transitions occur
         if (hangfireState == SucceededState.StateName ||
             hangfireState == DeletedState.StateName ||
             hangfireState == FailedState.StateName)
         {
-            return WorkflowAttributes.WorkflowStateValues.Completed;
+            return null;
         }
 
         return null;
@@ -42,12 +46,14 @@ internal static class HangfireStateMapper
 
     /// <summary>
     /// Maps Hangfire state names to workflow-level semantic convention state values.
-    /// Tracks the complete workflow lifecycle: scheduled jobs waiting for trigger time,
-    /// enqueued jobs waiting in queue, executing jobs, and completed jobs.
+    /// Tracks the workflow lifecycle: scheduled jobs waiting for trigger time,
+    /// enqueued jobs waiting in queue, and executing jobs.
     /// Note: "pending" at workflow level includes both scheduled (waiting for time) and enqueued (waiting for worker).
+    /// Final states (Succeeded, Failed, Deleted) are not tracked in the status metric
+    /// as they represent terminal states that no longer transition.
     /// </summary>
     /// <param name="hangfireState">Hangfire state name.</param>
-    /// <returns>Mapped workflow state value, or <see langword="null"/> if the state is not recognized.</returns>
+    /// <returns>Mapped workflow state value, or <see langword="null"/> if the state is not recognized or is a final state.</returns>
     public static string? MapWorkflowState(string? hangfireState)
     {
         // Scheduled and Enqueued/Awaiting are both "pending" at workflow level
@@ -65,11 +71,13 @@ internal static class HangfireStateMapper
             return WorkflowAttributes.WorkflowStateValues.Executing;
         }
 
+        // Final states (Succeeded, Failed, Deleted) are not tracked in status metric
+        // as they represent terminal states where no further transitions occur
         if (hangfireState == SucceededState.StateName ||
             hangfireState == DeletedState.StateName ||
             hangfireState == FailedState.StateName)
         {
-            return WorkflowAttributes.WorkflowStateValues.Completed;
+            return null;
         }
 
         return null;
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index 842f25db3a..1867f7ac1e 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -60,7 +60,7 @@ public static TagList BuildExecutionstatusTags(BackgroundJob backgroundJob, stri
 
     /// <summary>
     /// Creates a tag list with execution result tags following workflow semantic conventions.
-    /// Includes required attributes (workflow.task.name, workflow.execution.outcome, workflow.execution.state),
+    /// Includes required attributes (workflow.task.name, workflow.execution.result, workflow.execution.state),
     /// recommended attributes (workflow.platform.name),
     /// conditionally required attributes (error.type if failed).
     /// Note: workflow.trigger.type is NOT included as it belongs to workflow-level metrics only.
@@ -75,7 +75,7 @@ public static TagList BuildExecutionTags(BackgroundJob backgroundJob, Exception?
         {
             GetTaskName(backgroundJob),
             GetPlatformName(),
-            GetExecutionOutcome(exception),
+            GetExecutionResult(exception),
             GetState(workflowState),
         };
 
@@ -89,22 +89,22 @@ public static TagList BuildExecutionTags(BackgroundJob backgroundJob, Exception?
     }
 
     /// <summary>
-    /// Creates a tag list for workflow.execution.count metric following workflow semantic conventions.
-    /// Includes required attributes (workflow.task.name, workflow.execution.outcome),
+    /// Creates a tag list for workflow.execution.outcome metric following workflow semantic conventions.
+    /// Includes required attributes (workflow.task.name, workflow.execution.result),
     /// recommended attributes (workflow.platform.name),
     /// conditionally required attributes (error.type if failed).
-    /// Note: Does NOT include workflow.execution.state as it's not specified in semantic conventions for count metric.
+    /// Note: Does NOT include workflow.execution.state as it's not specified in semantic conventions for outcome metric.
     /// </summary>
     /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <param name="exception">The exception, if any occurred.</param>
-    /// <returns>Tag list suitable for workflow.execution.count metric.</returns>
+    /// <returns>Tag list suitable for workflow.execution.outcome metric.</returns>
     public static TagList BuildExecutionCountTags(BackgroundJob backgroundJob, Exception? exception)
     {
         var tags = new TagList
         {
             GetTaskName(backgroundJob),
             GetPlatformName(),
-            GetExecutionOutcome(exception),
+            GetExecutionResult(exception),
         };
 
         // Conditionally Required: error.type (if and only if the task run failed)
@@ -118,22 +118,22 @@ public static TagList BuildExecutionCountTags(BackgroundJob backgroundJob, Excep
 
     /// <summary>
     /// Creates a tag list for workflow-level metrics following workflow semantic conventions.
-    /// Includes required attributes (workflow.definition.name, workflow.outcome, workflow.trigger.type),
+    /// Includes required attributes (workflow.definition.name, workflow.result, workflow.trigger.type),
     /// recommended attributes (workflow.platform.name),
     /// conditionally required attributes (error.type if failed).
-    /// Used for workflow.count and other workflow-level (not execution-level) metrics.
+    /// Used for workflow.outcome and other workflow-level (not execution-level) metrics.
     /// </summary>
     /// <param name="backgroundJob">The Hangfire background job.</param>
     /// <param name="exception">The exception, if any occurred.</param>
     /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
-    /// <returns>Tag list suitable for workflow.count metric.</returns>
+    /// <returns>Tag list suitable for workflow.outcome metric.</returns>
     public static TagList BuildWorkflowTags(BackgroundJob backgroundJob, Exception? exception, string? recurringJobId)
     {
         var tags = new TagList
         {
             GetDefinitionName(backgroundJob),
             GetPlatformName(),
-            GetWorkflowOutcome(exception),
+            GetWorkflowResult(exception),
             GetTriggerType(recurringJobId),
         };
 
@@ -154,7 +154,7 @@ public static TagList BuildWorkflowTags(BackgroundJob backgroundJob, Exception?
     /// Used for tracking workflow state transitions (e.g., scheduled jobs).
     /// </summary>
     /// <param name="backgroundJob">The Hangfire background job.</param>
-    /// <param name="workflowState">The workflow state value (e.g., "pending", "executing", "completed").</param>
+    /// <param name="workflowState">The workflow state value (e.g., "pending", "executing", "finalizing").</param>
     /// <param name="recurringJobId">Optional recurring job ID if this job was triggered by a recurring job.</param>
     /// <param name="errorType">Optional error type to annotate failure states.</param>
     /// <returns>Tag list suitable for workflow.status metric.</returns>
@@ -206,11 +206,11 @@ public static TagList BuildErrorTags(PerformedContext performedContext)
     private static KeyValuePair<string, object?> GetDefinitionName(BackgroundJob backgroundJob) =>
         new(WorkflowAttributes.AttributeWorkflowDefinitionName, backgroundJob.FormatJobName());
 
-    private static KeyValuePair<string, object?> GetExecutionOutcome(Exception? exception) =>
-        new(WorkflowAttributes.AttributeWorkflowExecutionOutcome, exception is null ? WorkflowAttributes.WorkflowOutcomeValues.Success : WorkflowAttributes.WorkflowOutcomeValues.Failure);
+    private static KeyValuePair<string, object?> GetExecutionResult(Exception? exception) =>
+        new(WorkflowAttributes.AttributeWorkflowExecutionResult, exception is null ? WorkflowAttributes.WorkflowResultValues.Success : WorkflowAttributes.WorkflowResultValues.Failure);
 
-    private static KeyValuePair<string, object?> GetWorkflowOutcome(Exception? exception) =>
-        new(WorkflowAttributes.AttributeWorkflowOutcome, exception is null ? WorkflowAttributes.WorkflowOutcomeValues.Success : WorkflowAttributes.WorkflowOutcomeValues.Failure);
+    private static KeyValuePair<string, object?> GetWorkflowResult(Exception? exception) =>
+        new(WorkflowAttributes.AttributeWorkflowResult, exception is null ? WorkflowAttributes.WorkflowResultValues.Success : WorkflowAttributes.WorkflowResultValues.Failure);
 
     private static KeyValuePair<string, object?> GetTriggerType(string? recurringJobId, string? workflowState = null)
     {
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs
index 5dcd747c53..c13c6ec10b 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowAttributes.cs
@@ -24,14 +24,14 @@ internal static class WorkflowAttributes
     public const string AttributeWorkflowDefinitionName = "workflow.definition.name";
 
     /// <summary>
-    /// The outcome of executing the task.
+    /// The result of executing the task.
     /// </summary>
-    public const string AttributeWorkflowExecutionOutcome = "workflow.execution.outcome";
+    public const string AttributeWorkflowExecutionResult = "workflow.execution.result";
 
     /// <summary>
     /// The result of a workflow run.
     /// </summary>
-    public const string AttributeWorkflowOutcome = "workflow.outcome";
+    public const string AttributeWorkflowResult = "workflow.result";
 
     /// <summary>
     /// The execution state.
@@ -61,9 +61,9 @@ internal static class WorkflowAttributes
     // ===== Attribute Value Constants =====
 
     /// <summary>
-    /// Values for workflow.execution.outcome and workflow.outcome attributes.
+    /// Values for workflow.execution.result and workflow.result attributes.
     /// </summary>
-    public static class WorkflowOutcomeValues
+    public static class WorkflowResultValues
     {
         /// <summary>
         /// The execution/workflow finished successfully.
@@ -117,11 +117,6 @@ public static class WorkflowStateValues
         /// The finalizing state spans from when execution has finished and covers cleanup of resources, etc.
         /// </summary>
         public const string Finalizing = "finalizing";
-
-        /// <summary>
-        /// The completed state spans from when the workflow/execution has finished finalizing (eg. cleanup of resources).
-        /// </summary>
-        public const string Completed = "completed";
     }
 
     /// <summary>
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs
index cb4dae257a..cc196cf473 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/WorkflowMetricNames.cs
@@ -14,7 +14,7 @@ internal static class WorkflowMetricNames
     /// <summary>
     /// The number of task executions which have been initiated.
     /// </summary>
-    public const string ExecutionCount = "workflow.execution.count";
+    public const string ExecutionOutcome = "workflow.execution.outcome";
 
     /// <summary>
     /// Duration of an execution grouped by task, type and result.
@@ -34,7 +34,7 @@ internal static class WorkflowMetricNames
     /// <summary>
     /// The number of workflow instances which have been initiated.
     /// </summary>
-    public const string WorkflowCount = "workflow.count";
+    public const string WorkflowOutcome = "workflow.outcome";
 
     /// <summary>
     /// The number of actively running workflows grouped by definition and the current state.
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index bb36e01782..3e15447c79 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -269,18 +269,18 @@ var meterProvider = Sdk.CreateMeterProviderBuilder()
 The following metrics are emitted by this instrumentation:
 
 **Execution-level metrics** track jobs that have entered the execution pipeline:
-- `workflow.execution.count` - Counter for completed executions
+- `workflow.execution.outcome` - Counter for completed executions
 - `workflow.execution.duration` - Histogram for execution duration (pending and executing phases)
 - `workflow.execution.status` - UpDownCounter for current execution state
 - `workflow.execution.errors` - Counter for execution errors
 
 **Workflow-level metrics** track the complete job lifecycle:
-- `workflow.count` - Counter for completed workflows
+- `workflow.outcome` - Counter for completed workflows
 - `workflow.status` - UpDownCounter for current workflow state (including scheduled jobs)
 
 ---
 
-#### workflow.execution.count
+#### workflow.execution.outcome
 
 The number of task executions which have been initiated.
 
@@ -297,7 +297,7 @@ The number of task executions which have been initiated.
 | Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
 |-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`   |
-| `workflow.execution.outcome`  | string | The outcome of executing the task             | Required                 | `success`, `failure`    |
+| `workflow.execution.result`   | string | The result of executing the task              | Required                 | `success`, `failure`    |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
 | `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
 
@@ -324,7 +324,7 @@ execution phases:
 | Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
 |-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`   |
-| `workflow.execution.outcome`  | string | The outcome of executing the task             | Required                 | `success`, `failure`    |
+| `workflow.execution.result`   | string | The result of executing the task              | Required                 | `success`, `failure`    |
 | `workflow.execution.state`    | string | The execution phase being measured            | Required                 | `pending`, `executing`  |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
 | `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
@@ -380,7 +380,7 @@ The number of errors encountered in task executions.
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required          | e.g., `MyJob.Execute`   |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended       | `hangfire`              |
 
-#### workflow.count
+#### workflow.outcome
 
 The number of workflow instances which have been initiated. In Hangfire, this tracks
 individual job completions.
@@ -394,7 +394,7 @@ individual job completions.
 | Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
 |-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
 | `workflow.definition.name`    | string | Name of the workflow (Hangfire job method)    | Required                 | e.g., `MyJob.Execute`   |
-| `workflow.outcome`            | string | The outcome of the workflow                   | Required                 | `success`, `failure`    |
+| `workflow.result`             | string | The result of the workflow                    | Required                 | `success`, `failure`    |
 | `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`, `schedule` |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
 | `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
@@ -461,13 +461,13 @@ This instrumentation follows the OpenTelemetry semantic conventions for workflow
 - **workflow.platform.name**: Always set to `"hangfire"`
 - **workflow.task.name** / **workflow.definition.name**: Derived from the Hangfire job method (e.g., `ClassName.MethodName`)
   - `workflow.task.name` is used for execution-level metrics (`workflow.execution.*`)
-  - `workflow.definition.name` is used for workflow-level metrics (`workflow.count`, `workflow.status`)
+  - `workflow.definition.name` is used for workflow-level metrics (`workflow.outcome`, `workflow.status`)
 - **workflow.trigger.type**: Identifies how the job was initiated
   - `"cron"` for recurring jobs
   - `"schedule"` for delayed jobs (scheduled for future execution)
   - `"api"` for fire-and-forget and continuation jobs
-  - Only included on workflow-level metrics (`workflow.count`, `workflow.status`), not on execution-level metrics (`workflow.execution.*`)
-- **workflow.execution.outcome** / **workflow.outcome**: Set to `"success"` when jobs complete without errors,
+  - Only included on workflow-level metrics (`workflow.outcome`, `workflow.status`), not on execution-level metrics (`workflow.execution.*`)
+- **workflow.execution.result** / **workflow.result**: Set to `"success"` when jobs complete without errors,
   `"failure"` when an exception is thrown
 - **workflow.execution.state** / **workflow.state**: Maps Hangfire states to semantic convention states
   - `workflow.execution.state` tracks execution pipeline states (used in `workflow.execution.status`, `workflow.execution.duration`)
@@ -479,7 +479,7 @@ This instrumentation follows the OpenTelemetry semantic conventions for workflow
 
 The instrumentation distinguishes between **workflow-level** and **execution-level** metrics:
 
-**Workflow-level metrics** (`workflow.count`, `workflow.status`):
+**Workflow-level metrics** (`workflow.outcome`, `workflow.status`):
 - Track the complete lifecycle of jobs, including pre-execution states (e.g., scheduled)
 - Use `workflow.definition.name`, `workflow.state`, and `workflow.trigger.type`
 - Provide visibility into all jobs regardless of execution status
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index 788cf45c81..1d3207f8a4 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -21,7 +21,7 @@ public HangfireMetricsTests(HangfireFixture hangfireFixture)
     }
 
     [Fact]
-    public async Task Should_Record_ExecutionCount_Metric_When_Job_Executes()
+    public async Task Should_Record_ExecutionOutcome_Metric_When_Job_Executes()
     {
         // Arrange
         var exportedItems = new List<Metric>();
@@ -37,20 +37,20 @@ public async Task Should_Record_ExecutionCount_Metric_When_Job_Executes()
         meterProvider.ForceFlush();
 
         // Assert
-        var executionCountMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionCount);
-        AssertUtils.AssertHasMetricPoints(executionCountMetric);
-        Assert.Equal("{executions}", executionCountMetric!.Unit);
-        Assert.Equal(MetricType.LongSum, executionCountMetric.MetricType);
+        var executionOutcomeMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionOutcome);
+        AssertUtils.AssertHasMetricPoints(executionOutcomeMetric);
+        Assert.Equal("{executions}", executionOutcomeMetric!.Unit);
+        Assert.Equal(MetricType.LongSum, executionOutcomeMetric.MetricType);
 
-        var metricPoints = executionCountMetric.ToMetricPointList();
+        var metricPoints = executionOutcomeMetric.ToMetricPointList();
         var sum = metricPoints.First().GetSumLong();
-        Assert.True(sum >= 1, $"Expected workflow.execution.count sum >= 1, got {sum}");
+        Assert.True(sum >= 1, $"Expected workflow.execution.outcome sum >= 1, got {sum}");
 
         // Validate tags
         var metricPoint = metricPoints.First();
         AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName);
         AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Success);
     }
 
     [Fact]
@@ -87,7 +87,7 @@ public async Task Should_Record_ExecutionDuration_Metric_For_Successful_Job()
         // Validate tags for successful execution
         AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName);
         AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Success);
 
         // Error type should NOT be present for successful execution
         AssertUtils.AssertHasNoTag(metricPoint, WorkflowAttributes.AttributeErrorType);
@@ -122,7 +122,7 @@ public async Task Should_Record_ExecutionDuration_Metric_With_ErrorType_For_Fail
         // Validate tags for failed execution
         AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowTaskName);
         AssertUtils.AssertHasTag(metricPoint, WorkflowAttributes.AttributeWorkflowPlatformName);
-        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Failure);
+        AssertUtils.AssertHasTagValue(metricPoint, WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Failure);
 
         // Error type is conditionally required for failed execution
         AssertUtils.AssertTagContains(metricPoint, WorkflowAttributes.AttributeErrorType, "Exception");
@@ -205,23 +205,16 @@ public async Task Should_Record_ExecutionStatus_States_For_Successful_Job()
             AssertUtils.AssertHasNoTag(point, WorkflowAttributes.AttributeWorkflowTriggerType);
         }
 
-        // Verify state transitions balance out to final state
+        // Verify state transitions balance out (all states should sum to 0 as job completes and exits status tracking)
         var pendingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
         var executingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;
-        var completedSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed)?.GetSumLong() ?? 0;
+        var finalizingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Finalizing)?.GetSumLong() ?? 0;
 
         Assert.Equal(0, pendingSum);
         Assert.Equal(0, executingSum);
-        Assert.Equal(1, completedSum);
+        Assert.Equal(0, finalizingSum);
 
-        // Verify completed state has correct attributes
-        var completedPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
-        Assert.NotNull(completedPoint);
-
-        AssertUtils.AssertHasNoTag(completedPoint.Value, WorkflowAttributes.AttributeErrorType);
-
-        // Note: trigger.type should NOT be on execution-level metrics per semantic conventions
-        AssertUtils.AssertHasNoTag(completedPoint.Value, WorkflowAttributes.AttributeWorkflowTriggerType);
+        // Completed is no longer a state in semantic conventions - jobs exit status tracking when they complete
     }
 
     [Fact]
@@ -247,24 +240,16 @@ public async Task Should_Record_ExecutionStatus_ErrorType_For_Failed_Job()
 
         var metricPoints = statusMetric.ToMetricPointList();
 
-        // Verify state transitions balance out to final state (completed with error)
+        // Verify state transitions balance out (all states should sum to 0 as job completes and exits status tracking)
         var pendingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
         var executingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;
-        var completedSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed)?.GetSumLong() ?? 0;
+        var finalizingSum = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Finalizing)?.GetSumLong() ?? 0;
 
         Assert.Equal(0, pendingSum);
         Assert.Equal(0, executingSum);
-        Assert.Equal(1, completedSum);
-
-        // Find the completed state metric point (should have error type for failed job)
-        var completedPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
-        Assert.NotNull(completedPoint);
-
-        // Verify error type is present and contains exception information
-        AssertUtils.AssertTagContains(completedPoint.Value, WorkflowAttributes.AttributeErrorType, "Exception");
+        Assert.Equal(0, finalizingSum);
 
-        // Note: trigger.type should NOT be on execution-level metrics per semantic conventions
-        AssertUtils.AssertHasNoTag(completedPoint.Value, WorkflowAttributes.AttributeWorkflowTriggerType);
+        // Completed is no longer a state in semantic conventions - jobs exit status tracking when they complete
     }
 
     [Fact]
@@ -292,16 +277,16 @@ public async Task Should_Record_All_Metrics_For_Multiple_Jobs()
         meterProvider.ForceFlush();
 
         // Assert - All metric types should be present
-        exportedItems.GetMetric(WorkflowMetricNames.ExecutionCount);
+        exportedItems.GetMetric(WorkflowMetricNames.ExecutionOutcome);
         exportedItems.GetMetric(WorkflowMetricNames.ExecutionDuration);
         exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
-        exportedItems.GetMetric(WorkflowMetricNames.WorkflowCount);
+        exportedItems.GetMetric(WorkflowMetricNames.WorkflowOutcome);
 
-        // Verify execution.count has at least 3 executions
-        var executionCountMetric = exportedItems.First(m => m.Name == WorkflowMetricNames.ExecutionCount);
-        var executionCountPoints = executionCountMetric.ToMetricPointList();
+        // Verify execution.outcome has at least 3 executions
+        var executionOutcomeMetric = exportedItems.First(m => m.Name == WorkflowMetricNames.ExecutionOutcome);
+        var executionOutcomePoints = executionOutcomeMetric.ToMetricPointList();
 
-        var totalExecutions = executionCountPoints.Sum(mp => mp.GetSumLong());
+        var totalExecutions = executionOutcomePoints.Sum(mp => mp.GetSumLong());
         Assert.True(totalExecutions >= 3, $"Expected at least 3 executions, got {totalExecutions}");
     }
 
@@ -330,13 +315,13 @@ public async Task Should_Track_Success_And_Failure_Outcomes_Separately()
 
         var metricPoints = durationMetric!.ToMetricPointList();
 
-        // Verify success outcome exists without error type
-        var successPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
+        // Verify success result exists without error type
+        var successPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Success);
         Assert.NotNull(successPoint);
         AssertUtils.AssertHasNoTag(successPoint.Value, WorkflowAttributes.AttributeErrorType);
 
-        // Verify failure outcome exists with error type
-        var failurePoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Failure);
+        // Verify failure result exists with error type
+        var failurePoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Failure);
         Assert.NotNull(failurePoint);
         AssertUtils.AssertHasTag(failurePoint.Value, WorkflowAttributes.AttributeErrorType);
     }
@@ -359,12 +344,12 @@ public async Task Should_Record_TriggerType_Cron_For_Recurring_Jobs_On_Workflow_
 
         meterProvider.ForceFlush();
 
-        // Assert - Check workflow.count metric has cron trigger type (NOT execution-level metrics)
-        var workflowCountMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowCount);
-        AssertUtils.AssertHasMetricPoints(workflowCountMetric);
-        var metricPoints = workflowCountMetric!.ToMetricPointList();
+        // Assert - Check workflow.outcome metric has cron trigger type (NOT execution-level metrics)
+        var workflowOutcomeMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowOutcome);
+        AssertUtils.AssertHasMetricPoints(workflowOutcomeMetric);
+        var metricPoints = workflowOutcomeMetric!.ToMetricPointList();
 
-        // Find the workflow.count metric point
+        // Find the workflow.outcome metric point
         var workflowPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Cron);
 
         Assert.NotNull(workflowPoint);
@@ -465,19 +450,22 @@ public async Task Should_Track_Job_In_Both_Workflow_And_Execution_Metrics()
 
         var workflowPoints = workflowStatusMetric!.ToMetricPointList();
 
-        // Pending state transitions: +1 (scheduled) -1 (enqueued) +1 (enqueued) -1 (executing) = 0
+        // Pending state transitions should balance to 0: +1 (scheduled) -1 (enqueued) +1 (enqueued) -1 (executing) = 0
         var workflowPendingPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Pending);
         if (workflowPendingPoint != null)
         {
             Assert.Equal(0, workflowPendingPoint.Value.GetSumLong());
         }
 
-        // Final workflow state should be completed (+1)
-        var workflowCompletedPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Completed);
-        Assert.NotNull(workflowCompletedPoint);
-        Assert.Equal(1, workflowCompletedPoint.Value.GetSumLong());
+        // Final workflow state - all states should be 0 as job exits status tracking when completed
+        // (Completed state no longer exists in semantic conventions)
+        var workflowExecutingPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Executing);
+        if (workflowExecutingPoint != null)
+        {
+            Assert.Equal(0, workflowExecutingPoint.Value.GetSumLong());
+        }
 
-        // Assert - workflow.execution.status should also track lifecycle (enqueued → executing → completed)
+        // Assert - workflow.execution.status should also track lifecycle (enqueued → executing)
         // but NOT the scheduled phase
         var executionStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
         AssertUtils.AssertHasMetricPoints(executionStatusMetric);
@@ -491,10 +479,13 @@ public async Task Should_Track_Job_In_Both_Workflow_And_Execution_Metrics()
             Assert.Equal(0, execPendingPoint.Value.GetSumLong());
         }
 
-        // Final execution state should be completed (+1)
-        var execCompletedPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
-        Assert.NotNull(execCompletedPoint);
-        Assert.Equal(1, execCompletedPoint.Value.GetSumLong());
+        // Final execution state - all states should be 0 as job exits status tracking when completed
+        // (Completed state no longer exists in semantic conventions)
+        var execExecutingPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing);
+        if (execExecutingPoint != null)
+        {
+            Assert.Equal(0, execExecutingPoint.Value.GetSumLong());
+        }
     }
 
     [Fact]
@@ -513,23 +504,27 @@ public async Task Should_Track_FireAndForget_Job_In_Both_Metrics()
 
         meterProvider.ForceFlush();
 
-        // Assert - Should appear in BOTH workflow.status AND workflow.execution.status
+        // Assert - Should appear in BOTH workflow.status AND workflow.execution.status while processing
         var workflowStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowStatus);
         AssertUtils.AssertHasMetricPoints(workflowStatusMetric);
 
         var workflowPoints = workflowStatusMetric!.ToMetricPointList();
-        var workflowCompletedPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Completed);
-        Assert.NotNull(workflowCompletedPoint);
-        Assert.Equal(1, workflowCompletedPoint.Value.GetSumLong());
+        // After completion, states should balance to 0 (Completed state no longer exists)
+        var workflowPendingSum = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
+        var workflowExecutingSum = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;
+        Assert.Equal(0, workflowPendingSum);
+        Assert.Equal(0, workflowExecutingSum);
 
         // Also in execution.status
         var executionStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
         AssertUtils.AssertHasMetricPoints(executionStatusMetric);
 
         var execPoints = executionStatusMetric!.ToMetricPointList();
-        var execCompletedPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Completed);
-        Assert.NotNull(execCompletedPoint);
-        Assert.Equal(1, execCompletedPoint.Value.GetSumLong());
+        // After completion, states should balance to 0 (Completed state no longer exists)
+        var execPendingSum = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
+        var execExecutingSum = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;
+        Assert.Equal(0, execPendingSum);
+        Assert.Equal(0, execExecutingSum);
 
         // Verify workflow.status uses trigger.type=api for fire-and-forget
         var apiTriggerPoint = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowTriggerType, WorkflowAttributes.WorkflowTriggerTypeValues.Api);
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
index 205f50350c..7a98336d2f 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
@@ -93,7 +93,7 @@ public async Task Should_Record_PendingDuration_When_RecordQueueLatency_Enabled(
         AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowTaskName);
         AssertUtils.AssertHasTag(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowPlatformName);
         AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
-        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Success);
     }
 
     [Fact]
@@ -198,12 +198,12 @@ public async Task Should_Record_PendingDuration_For_Failed_Job()
         Assert.NotNull(pendingPoint);
 
         // Pending phase should be successful (job started executing)
-        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Success);
+        AssertUtils.AssertHasTagValue(pendingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Success);
 
-        // Executing phase should have failure outcome
+        // Executing phase should have failure result
         var executingPoint = metricPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing);
         Assert.NotNull(executingPoint);
-        AssertUtils.AssertHasTagValue(executingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionOutcome, WorkflowAttributes.WorkflowOutcomeValues.Failure);
+        AssertUtils.AssertHasTagValue(executingPoint.Value, WorkflowAttributes.AttributeWorkflowExecutionResult, WorkflowAttributes.WorkflowResultValues.Failure);
     }
 
     [Fact]

From b58920e0e8ac38aea6a15d16172b273b4b88038f Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Sun, 26 Oct 2025 10:32:46 -0400
Subject: [PATCH 19/48] Remove `DisplayNameFunc` from PublicAPI.Unshipped.txt
 and README.md

---
 .../.publicApi/PublicAPI.Unshipped.txt          |  2 --
 .../README.md                                   | 17 -----------------
 2 files changed, 19 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt b/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
index 275b190168..2de2b9b98c 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/.publicApi/PublicAPI.Unshipped.txt
@@ -12,8 +12,6 @@ static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumen
 static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
 static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddHangfireInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, System.Action<OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions!>? configure) -> OpenTelemetry.Metrics.MeterProviderBuilder!
 OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions
-OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.DisplayNameFunc.get -> System.Func<Hangfire.BackgroundJob!, string!>!
-OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.DisplayNameFunc.set -> void
 OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.HangfireMetricsInstrumentationOptions() -> void
 OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.RecordQueueLatency.get -> bool
 OpenTelemetry.Metrics.HangfireMetricsInstrumentationOptions.RecordQueueLatency.set -> void
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 3e15447c79..2d5423b63e 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -247,23 +247,6 @@ execution time.
 > [!NOTE]
 > Add `using OpenTelemetry.Metrics;` to access `HangfireMetricsInstrumentationOptions`.
 
-#### DisplayNameFunc
-
-Metrics use the `DisplayNameFunc` from `HangfireMetricsInstrumentationOptions` to populate
-`workflow.task.name` and related attributes. By default, it calls `backgroundJob.Job.ToString()`,
-but you can provide your own formatter:
-
-```csharp
-var meterProvider = Sdk.CreateMeterProviderBuilder()
-    .AddHangfireInstrumentation(options =>
-    {
-        options.DisplayNameFunc = backgroundJob => $"{backgroundJob.Job.Type.Name}:{backgroundJob.Id}";
-    })
-    .AddConsoleExporter()
-    .Build();
-```
-
-
 ### Available Metrics
 
 The following metrics are emitted by this instrumentation:

From 90022d01a326f835d3ca7b5f18c87cb82c412f4f Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Tue, 28 Oct 2025 16:01:40 -0400
Subject: [PATCH 20/48] remove wrong link

---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 2d5423b63e..f19538793d 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -477,4 +477,3 @@ The instrumentation distinguishes between **workflow-level** and **execution-lev
 
 * [OpenTelemetry Project](https://opentelemetry.io/)
 * [Hangfire Project](https://www.hangfire.io/)
-* [OpenTelemetry Workflow Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md)

From ded8e6695085ea145c45c4e5ec38c6b6c4380b46 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Tue, 28 Oct 2025 16:11:20 -0400
Subject: [PATCH 21/48] update CHANGELOG.md

---
 src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md b/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
index 587cef020f..75ccd01128 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+* Add metrics instrumentation following workflow semantic conventions.
+  ([#3258](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/3258))
+
 ## 1.13.0-beta.1
 
 Released 2025-Oct-23

From 2c494a945a02e82a1080455010b430f5ab06166b Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Fri, 14 Nov 2025 20:39:56 -0500
Subject: [PATCH 22/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index f19538793d..3073a4e93b 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -166,8 +166,8 @@ using var tracerProvider = Sdk
 
 ## Metrics
 
-This instrumentation library collects metrics following the OpenTelemetry
-[workflow semantic conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/workflow/workflow-metrics.md).
+This instrumentation library collects metrics following a POC/draft definition of workflow metrics defined as part of [semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688). 
+As those definitions evolve, changes including breaking ones will flow back to this implementation.
 
 In Hangfire, the workflow semantic conventions are applied as follows:
 - Each background job execution is modeled as a **workflow task execution**

From ecd316329f27e2ba604cbbd4d40c75e8b9e817c4 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Fri, 14 Nov 2025 20:47:31 -0500
Subject: [PATCH 23/48] update CHANGELOG.md

---
 src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md b/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
index 75ccd01128..f18d7afb6f 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
@@ -2,8 +2,7 @@
 
 ## Unreleased
 
-* Add metrics instrumentation following workflow semantic conventions.
-  ([#3258](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/3258))
+* Add metrics instrumentation following a POC/draft definition of workflow metrics defined as part of [semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688).
 
 ## 1.13.0-beta.1
 

From d4186b4a7487d4aa9ddf95f22b27ae5ec14b043d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Piotr=20Kie=C5=82kowicz?= <pkiekowicz@splunk.com>
Date: Mon, 17 Nov 2025 07:06:25 +0100
Subject: [PATCH 24/48] CHANGELOG fix

---
 src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md b/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
index 663d5be80c..fe9160c441 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/CHANGELOG.md
@@ -2,7 +2,9 @@
 
 ## Unreleased
 
-* Add metrics instrumentation following a POC/draft definition of workflow metrics defined as part of [semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688).
+* Add metrics instrumentation following a POC/draft definition of workflow metrics
+  defined as part of [semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688).
+  ([#3258](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/3258))
 
 ## 1.14.0-beta.1
 

From 6ec1c12a51db7ace3a0aa017ff00198917d3dd33 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Mon, 17 Nov 2025 10:48:18 -0500
Subject: [PATCH 25/48] Fix build

---
 .../HangfireMetricsInstrumentationOptions.cs  |  2 --
 .../Implementation/HangfireMetrics.cs         | 34 +++++++++----------
 .../HangfireMetricsErrorFilterAttribute.cs    |  1 -
 .../HangfireMetricsStateFilter.cs             | 28 +++++++--------
 .../Implementation/HangfireTagBuilder.cs      |  1 -
 .../Implementation/TypeExtensions.cs          |  8 +++--
 .../CustomTestException.cs                    |  3 +-
 .../HangfireFixture.cs                        |  8 +++--
 .../HangfireMetricsTests.cs                   |  3 ++
 9 files changed, 48 insertions(+), 40 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
index 9c038c58c3..d017d3f79c 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/HangfireMetricsInstrumentationOptions.cs
@@ -1,8 +1,6 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-using Hangfire;
-
 namespace OpenTelemetry.Metrics;
 
 /// <summary>
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
index ccf864bea5..c5467354ad 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
@@ -12,23 +12,12 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 /// </summary>
 internal static class HangfireMetrics
 {
-    internal static readonly Assembly Assembly = typeof(HangfireMetrics).Assembly;
-    internal static readonly AssemblyName AssemblyName = Assembly.GetName();
-    internal static readonly string MeterName = AssemblyName.Name!;
-
-    private static readonly string InstrumentationVersion = Assembly.GetPackageVersion();
-
-    /// <summary>
-    /// The meter instance for all Hangfire metrics.
-    /// </summary>
-    private static readonly Meter Meter = new(MeterName, InstrumentationVersion);
-
     /// <summary>
     /// Counter for the number of task executions which have been initiated.
     /// Follows OpenTelemetry workflow semantic conventions.
     /// </summary>
     public static readonly Counter<long> ExecutionOutcome =
-        Meter.CreateCounter<long>(
+        Meter!.CreateCounter<long>(
             WorkflowMetricNames.ExecutionOutcome,
             unit: "{executions}",
             description: "The number of task executions which have been initiated.");
@@ -41,7 +30,7 @@ internal static class HangfireMetrics
     /// - state=executing: Time spent in actual execution.
     /// </summary>
     public static readonly Histogram<double> ExecutionDuration =
-        Meter.CreateHistogram<double>(
+        Meter!.CreateHistogram<double>(
             WorkflowMetricNames.ExecutionDuration,
             unit: "s",
             description: "Duration of an execution grouped by task, type and result.");
@@ -51,7 +40,7 @@ internal static class HangfireMetrics
     /// Follows OpenTelemetry workflow semantic conventions.
     /// </summary>
     public static readonly UpDownCounter<long> ExecutionStatus =
-        Meter.CreateUpDownCounter<long>(
+        Meter!.CreateUpDownCounter<long>(
             WorkflowMetricNames.ExecutionStatus,
             unit: "{executions}",
             description: "The number of actively running tasks grouped by task, type and the current state.");
@@ -61,7 +50,7 @@ internal static class HangfireMetrics
     /// Follows OpenTelemetry workflow semantic conventions.
     /// </summary>
     public static readonly Counter<long> ExecutionErrors =
-        Meter.CreateCounter<long>(
+        Meter!.CreateCounter<long>(
             WorkflowMetricNames.ExecutionErrors,
             unit: "{error}",
             description: "The number of errors encountered in task runs (eg. compile, test failures).");
@@ -72,7 +61,7 @@ internal static class HangfireMetrics
     /// In Hangfire, this tracks individual job completions. For batch workflows, this would track batch completion.
     /// </summary>
     public static readonly Counter<long> WorkflowOutcome =
-        Meter.CreateCounter<long>(
+        Meter!.CreateCounter<long>(
             WorkflowMetricNames.WorkflowOutcome,
             unit: "{workflows}",
             description: "The number of workflow instances which have been initiated.");
@@ -83,8 +72,19 @@ internal static class HangfireMetrics
     /// In Hangfire, this tracks workflows that haven't entered the execution pipeline yet (e.g., scheduled jobs).
     /// </summary>
     public static readonly UpDownCounter<long> WorkflowStatus =
-        Meter.CreateUpDownCounter<long>(
+        Meter!.CreateUpDownCounter<long>(
             WorkflowMetricNames.WorkflowStatus,
             unit: "{workflows}",
             description: "The number of actively running workflows grouped by definition and the current state.");
+
+    internal static readonly Assembly Assembly = typeof(HangfireMetrics).Assembly;
+    internal static readonly AssemblyName AssemblyName = Assembly.GetName();
+    internal static readonly string MeterName = AssemblyName.Name!;
+
+    private static readonly string InstrumentationVersion = Assembly.GetPackageVersion();
+
+    /// <summary>
+    /// The meter instance for all Hangfire metrics.
+    /// </summary>
+    private static readonly Meter Meter = new(MeterName, InstrumentationVersion);
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
index ca07844672..d29ca806c6 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsErrorFilterAttribute.cs
@@ -3,7 +3,6 @@
 
 using Hangfire.Common;
 using Hangfire.Server;
-using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index e670223718..feca75fad7 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -18,6 +18,18 @@ private enum StateTransitionDirection
         Unapplied,
     }
 
+    public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
+    {
+        RecordWorkflowStateChange(context, StateTransitionDirection.Applied);
+        RecordExecutionStateChange(context, StateTransitionDirection.Applied);
+    }
+
+    public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
+    {
+        RecordWorkflowStateChange(context, StateTransitionDirection.Unapplied);
+        RecordExecutionStateChange(context, StateTransitionDirection.Unapplied);
+    }
+
     private static string? GetErrorTypeFromNewState(IState state)
     {
         if (!string.Equals(state.Name, FailedState.StateName, StringComparison.Ordinal))
@@ -74,19 +86,7 @@ private enum StateTransitionDirection
         }
     }
 
-    public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
-    {
-        this.RecordWorkflowStateChange(context, StateTransitionDirection.Applied);
-        this.RecordExecutionStateChange(context, StateTransitionDirection.Applied);
-    }
-
-    public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
-    {
-        this.RecordWorkflowStateChange(context, StateTransitionDirection.Unapplied);
-        this.RecordExecutionStateChange(context, StateTransitionDirection.Unapplied);
-    }
-
-    private void RecordWorkflowStateChange(
+    private static void RecordWorkflowStateChange(
         ApplyStateContext context,
         StateTransitionDirection direction)
     {
@@ -117,7 +117,7 @@ private void RecordWorkflowStateChange(
         HangfireMetrics.WorkflowStatus.Add(delta, tags);
     }
 
-    private void RecordExecutionStateChange(
+    private static void RecordExecutionStateChange(
         ApplyStateContext context,
         StateTransitionDirection direction)
     {
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
index 1867f7ac1e..dfbe1c07eb 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireTagBuilder.cs
@@ -57,7 +57,6 @@ public static TagList BuildExecutionstatusTags(BackgroundJob backgroundJob, stri
         return tags;
     }
 
-
     /// <summary>
     /// Creates a tag list with execution result tags following workflow semantic conventions.
     /// Includes required attributes (workflow.task.name, workflow.execution.result, workflow.execution.state),
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
index 448aef1f9b..07c1dc83df 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
@@ -1,4 +1,7 @@
-using System.Globalization;
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Globalization;
 using System.Reflection;
 using System.Text.RegularExpressions;
 
@@ -35,8 +38,9 @@ private static string GetFullNameWithoutNamespace(this Type type)
             }
 
             const int dotLength = 1;
+
             // ReSharper disable once PossibleNullReferenceException
-            return !String.IsNullOrEmpty(type.Namespace)
+            return !string.IsNullOrEmpty(type.Namespace)
                 ? type.FullName.Substring(type.Namespace.Length + dotLength)
                 : type.FullName;
         }
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
index ac77b2d334..6a2f1752a8 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
@@ -8,7 +8,8 @@ namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
 /// </summary>
 internal class CustomTestException : Exception
 {
-    public CustomTestException(string message) : base(message)
+    public CustomTestException(string message)
+        : base(message)
     {
     }
 }
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
index 9535e71595..26b4244c31 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireFixture.cs
@@ -28,7 +28,7 @@ public HangfireFixture()
         // Default is 15 seconds, which is too slow for test scenarios
         var options = new BackgroundJobServerOptions
         {
-            SchedulePollingInterval = TimeSpan.FromMilliseconds(100)
+            SchedulePollingInterval = TimeSpan.FromMilliseconds(100),
         };
 
         this.Server = new BackgroundJobServer(options);
@@ -54,7 +54,11 @@ public async Task WaitJobProcessedAsync(string jobId, int timeToWaitInSeconds)
 
         while (!cts.IsCancellationRequested)
         {
-            if (Completed()) return;
+            if (Completed())
+            {
+                return;
+            }
+
             await Task.Delay(50, cts.Token);
         }
 
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index 1d3207f8a4..9b2c9433a9 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -420,6 +420,7 @@ public async Task Should_Record_WorkflowStatus_For_Scheduled_Jobs()
         if (executionStatusMetric != null)
         {
             var execPoints = executionStatusMetric.ToMetricPointList();
+
             // Should have no execution state metrics for scheduled jobs (not in execution pipeline)
             var execPendingPoint = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending);
             Assert.Null(execPendingPoint);
@@ -509,6 +510,7 @@ public async Task Should_Track_FireAndForget_Job_In_Both_Metrics()
         AssertUtils.AssertHasMetricPoints(workflowStatusMetric);
 
         var workflowPoints = workflowStatusMetric!.ToMetricPointList();
+
         // After completion, states should balance to 0 (Completed state no longer exists)
         var workflowPendingSum = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
         var workflowExecutingSum = workflowPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;
@@ -520,6 +522,7 @@ public async Task Should_Track_FireAndForget_Job_In_Both_Metrics()
         AssertUtils.AssertHasMetricPoints(executionStatusMetric);
 
         var execPoints = executionStatusMetric!.ToMetricPointList();
+
         // After completion, states should balance to 0 (Completed state no longer exists)
         var execPendingSum = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Pending)?.GetSumLong() ?? 0;
         var execExecutingSum = execPoints.FindFirstWithTag(WorkflowAttributes.AttributeWorkflowExecutionState, WorkflowAttributes.WorkflowStateValues.Executing)?.GetSumLong() ?? 0;

From 98d39254092ad39ab79492ab8e0fef49bca04a9c Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:32:17 -0500
Subject: [PATCH 26/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 3073a4e93b..8396684b74 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -468,6 +468,7 @@ The instrumentation distinguishes between **workflow-level** and **execution-lev
 - Provide visibility into all jobs regardless of execution status
 
 **Execution-level metrics** (`workflow.execution.*`):
+
 - Track only jobs that have entered the execution pipeline (enqueued or later)
 - Use `workflow.task.name` and `workflow.execution.state`
 - Do NOT include `workflow.trigger.type` (trigger is a workflow-level concept)

From 6683846b412a35f8395cd793c8a09c62f1a1ac2b Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:32:48 -0500
Subject: [PATCH 27/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 8396684b74..685cc13eaa 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -463,6 +463,7 @@ This instrumentation follows the OpenTelemetry semantic conventions for workflow
 The instrumentation distinguishes between **workflow-level** and **execution-level** metrics:
 
 **Workflow-level metrics** (`workflow.outcome`, `workflow.status`):
+
 - Track the complete lifecycle of jobs, including pre-execution states (e.g., scheduled)
 - Use `workflow.definition.name`, `workflow.state`, and `workflow.trigger.type`
 - Provide visibility into all jobs regardless of execution status

From 39eae7a166ab927024900fd0dc1c5e7df8b0ac43 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:33:07 -0500
Subject: [PATCH 28/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 685cc13eaa..7cb0d19041 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -290,6 +290,7 @@ The number of task executions which have been initiated.
 
 Duration of an execution grouped by task, state, and result. Records duration for different
 execution phases:
+
 - **state=pending**: Time spent waiting in queue (only when `RecordQueueLatency` is enabled)
 - **state=executing**: Time spent in actual execution
 

From 6b24590cc8b23c123fe82befa649d3e4c5c6096e Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:33:27 -0500
Subject: [PATCH 29/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 7cb0d19041..77502de9b3 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -258,6 +258,7 @@ The following metrics are emitted by this instrumentation:
 - `workflow.execution.errors` - Counter for execution errors
 
 **Workflow-level metrics** track the complete job lifecycle:
+
 - `workflow.outcome` - Counter for completed workflows
 - `workflow.status` - UpDownCounter for current workflow state (including scheduled jobs)
 

From ffc2a14639736e412547211771017090b651a91b Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:33:48 -0500
Subject: [PATCH 30/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 77502de9b3..7fe5b62bfc 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -384,7 +384,7 @@ individual job completions.
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
 | `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
 
-¹ Required if and only if the workflow execution failed.
+[1]: Required if and only if the workflow execution failed.
 
 #### workflow.status
 

From bf60f2b914b8f98da0313e5fb4ce4a2c5393609c Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:33:59 -0500
Subject: [PATCH 31/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 7fe5b62bfc..59b5316823 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -252,6 +252,7 @@ execution time.
 The following metrics are emitted by this instrumentation:
 
 **Execution-level metrics** track jobs that have entered the execution pipeline:
+
 - `workflow.execution.outcome` - Counter for completed executions
 - `workflow.execution.duration` - Histogram for execution duration (pending and executing phases)
 - `workflow.execution.status` - UpDownCounter for current execution state

From e4dfc844c5f543f952ec65e976ccad19463453be Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:34:10 -0500
Subject: [PATCH 32/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 59b5316823..3a9ff4b720 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -408,7 +408,7 @@ The number of actively running workflows grouped by definition and the current s
 | `workflow.state`              | string | Current state of the workflow                 | Required                 | `pending`, `executing`, `completed`       |
 | `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`, `schedule`                 |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`                                |
-| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name                       |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required[1] | Exception type name                       |
 
 ¹ Required if and only if the workflow execution failed.
 

From c5f113e47025ccfec1b24a922c286ac9a75d1926 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:34:21 -0500
Subject: [PATCH 33/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 3a9ff4b720..1a79bef644 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -410,7 +410,7 @@ The number of actively running workflows grouped by definition and the current s
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`                                |
 | `error.type`                  | string | The type of error that occurred               | Conditionally Required[1] | Exception type name                       |
 
-¹ Required if and only if the workflow execution failed.
+[1]: Required if and only if the workflow execution failed.
 
 **Hangfire State Mapping:**
 

From 53a98e2fe9b3ca3519eef8e51293388d59cddf0f Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:34:38 -0500
Subject: [PATCH 34/48] Update
 test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../HangfireMetricsTests.cs                                     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index 9b2c9433a9..045e74e532 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -445,7 +445,7 @@ public async Task Should_Track_Job_In_Both_Workflow_And_Execution_Metrics()
 
         meterProvider.ForceFlush();
 
-        // Assert - workflow.status should track full lifecycle (scheduled → enqueued → executing → completed)
+        // Assert - workflow.status should track full lifecycle (scheduled -> enqueued -> executing -> completed)
         var workflowStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.WorkflowStatus);
         AssertUtils.AssertHasMetricPoints(workflowStatusMetric);
 

From a4c3dd313bbb262381a6a552d47d28b315b9fe41 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:34:53 -0500
Subject: [PATCH 35/48] Update
 test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 .../HangfireMetricsTests.cs                                     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
index 045e74e532..cd476b8737 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireMetricsTests.cs
@@ -466,7 +466,7 @@ public async Task Should_Track_Job_In_Both_Workflow_And_Execution_Metrics()
             Assert.Equal(0, workflowExecutingPoint.Value.GetSumLong());
         }
 
-        // Assert - workflow.execution.status should also track lifecycle (enqueued → executing)
+        // Assert - workflow.execution.status should also track lifecycle (enqueued -> executing)
         // but NOT the scheduled phase
         var executionStatusMetric = exportedItems.GetMetric(WorkflowMetricNames.ExecutionStatus);
         AssertUtils.AssertHasMetricPoints(executionStatusMetric);

From 762e83b77c4676c4deb4390410365201fbcb6b30 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:44:22 -0500
Subject: [PATCH 36/48] Fix lint warnings

---
 .../README.md                                 | 21 ++++++++++---------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 1a79bef644..7564f7caef 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -166,10 +166,11 @@ using var tracerProvider = Sdk
 
 ## Metrics
 
-This instrumentation library collects metrics following a POC/draft definition of workflow metrics defined as part of [semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688). 
+This instrumentation library collects metrics following a POC/draft definition of workflow metrics defined as part of [semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688).
 As those definitions evolve, changes including breaking ones will flow back to this implementation.
 
 In Hangfire, the workflow semantic conventions are applied as follows:
+
 - Each background job execution is modeled as a **workflow task execution**
 - Workflow-level metrics track the complete lifecycle (including scheduled jobs)
 - Execution-level metrics track the execution pipeline (enqueued jobs and later)
@@ -284,9 +285,9 @@ The number of task executions which have been initiated.
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`   |
 | `workflow.execution.result`   | string | The result of executing the task              | Required                 | `success`, `failure`    |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
-| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required[1]  | Exception type name     |
 
-¹ Required if and only if the task execution failed.
+[1]: Required if and only if the task execution failed.
 
 #### workflow.execution.duration
 
@@ -313,9 +314,9 @@ execution phases:
 | `workflow.execution.result`   | string | The result of executing the task              | Required                 | `success`, `failure`    |
 | `workflow.execution.state`    | string | The execution phase being measured            | Required                 | `pending`, `executing`  |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
-| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required[1]  | Exception type name     |
 
-¹ Required if and only if the task execution failed.
+[1]: Required if and only if the task execution failed.
 
 #### workflow.execution.status
 
@@ -336,9 +337,9 @@ The number of actively running tasks grouped by task and the current state.
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`                     |
 | `workflow.execution.state`    | string | Current state of the execution                | Required                 | `pending`, `executing`, `completed`       |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`                                |
-| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name                       |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required[1]  | Exception type name                       |
 
-¹ Required if and only if the task execution failed.
+[1]: Required if and only if the task execution failed.
 
 **Hangfire State Mapping:**
 
@@ -383,7 +384,7 @@ individual job completions.
 | `workflow.result`             | string | The result of the workflow                    | Required                 | `success`, `failure`    |
 | `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`, `schedule` |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |
-| `error.type`                  | string | The type of error that occurred               | Conditionally Required¹  | Exception type name     |
+| `error.type`                  | string | The type of error that occurred               | Conditionally Required[1]  | Exception type name     |
 
 [1]: Required if and only if the workflow execution failed.
 
@@ -480,5 +481,5 @@ The instrumentation distinguishes between **workflow-level** and **execution-lev
 
 ## References
 
-* [OpenTelemetry Project](https://opentelemetry.io/)
-* [Hangfire Project](https://www.hangfire.io/)
+- [OpenTelemetry Project](https://opentelemetry.io/)
+- [Hangfire Project](https://www.hangfire.io/)

From c75d4e371cb41b1d6cb500a7bdfd321e6eead1cd Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:47:36 -0500
Subject: [PATCH 37/48] reformat code with dotnet format

---
 .../HangfireMetricsStateFilter.cs             |  2 +-
 .../Implementation/JobNameFormatter.cs        |  2 +-
 .../Implementation/TypeExtensions.cs          | 90 +++++++++----------
 3 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
index feca75fad7..7d19ff55b0 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetricsStateFilter.cs
@@ -1,4 +1,4 @@
-// Copyright The OpenTelemetry Authors
+// Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
 using Hangfire.Common;
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs
index 29bf42b5c3..565072e923 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/JobNameFormatter.cs
@@ -1,4 +1,4 @@
-// Copyright The OpenTelemetry Authors
+// Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
 using System.Text;
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
index 07c1dc83df..17d635ec70 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/TypeExtensions.cs
@@ -1,4 +1,4 @@
-// Copyright The OpenTelemetry Authors
+// Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
 using System.Globalization;
@@ -7,61 +7,61 @@
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
 
-    internal static class TypeExtensions
-    {
-        private static readonly Regex GenericArgumentsRegex = new Regex(@"`[1-9]\d*", RegexOptions.Compiled, TimeSpan.FromSeconds(5));
+internal static class TypeExtensions
+{
+    private static readonly Regex GenericArgumentsRegex = new Regex(@"`[1-9]\d*", RegexOptions.Compiled, TimeSpan.FromSeconds(5));
 
-        public static string ToGenericTypeString(this Type type)
+    public static string ToGenericTypeString(this Type type)
+    {
+        if (!type.GetTypeInfo().IsGenericType)
         {
-            if (!type.GetTypeInfo().IsGenericType)
-            {
-                return type.GetFullNameWithoutNamespace()
-                        .ReplacePlusWithDotInNestedTypeName();
-            }
-
-            return type.GetGenericTypeDefinition()
-                    .GetFullNameWithoutNamespace()
-                    .ReplacePlusWithDotInNestedTypeName()
-                    .ReplaceGenericParametersInGenericTypeName(type);
+            return type.GetFullNameWithoutNamespace()
+                    .ReplacePlusWithDotInNestedTypeName();
         }
 
-        public static Type[] GetAllGenericArguments(this TypeInfo type)
+        return type.GetGenericTypeDefinition()
+                .GetFullNameWithoutNamespace()
+                .ReplacePlusWithDotInNestedTypeName()
+                .ReplaceGenericParametersInGenericTypeName(type);
+    }
+
+    public static Type[] GetAllGenericArguments(this TypeInfo type)
+    {
+        return type.GenericTypeArguments.Length > 0 ? type.GenericTypeArguments : type.GenericTypeParameters;
+    }
+
+    private static string GetFullNameWithoutNamespace(this Type type)
+    {
+        if (type.IsGenericParameter)
         {
-            return type.GenericTypeArguments.Length > 0 ? type.GenericTypeArguments : type.GenericTypeParameters;
+            return type.Name;
         }
 
-        private static string GetFullNameWithoutNamespace(this Type type)
-        {
-            if (type.IsGenericParameter)
-            {
-                return type.Name;
-            }
+        const int dotLength = 1;
 
-            const int dotLength = 1;
+        // ReSharper disable once PossibleNullReferenceException
+        return !string.IsNullOrEmpty(type.Namespace)
+            ? type.FullName.Substring(type.Namespace.Length + dotLength)
+            : type.FullName;
+    }
 
-            // ReSharper disable once PossibleNullReferenceException
-            return !string.IsNullOrEmpty(type.Namespace)
-                ? type.FullName.Substring(type.Namespace.Length + dotLength)
-                : type.FullName;
-        }
+    private static string ReplacePlusWithDotInNestedTypeName(this string typeName)
+    {
+        return typeName.Replace('+', '.');
+    }
 
-        private static string ReplacePlusWithDotInNestedTypeName(this string typeName)
-        {
-            return typeName.Replace('+', '.');
-        }
+    private static string ReplaceGenericParametersInGenericTypeName(this string typeName, Type type)
+    {
+        var genericArguments = type.GetTypeInfo().GetAllGenericArguments();
 
-        private static string ReplaceGenericParametersInGenericTypeName(this string typeName, Type type)
+        typeName = GenericArgumentsRegex.Replace(typeName, match =>
         {
-            var genericArguments = type.GetTypeInfo().GetAllGenericArguments();
+            var currentGenericArgumentNumbers = int.Parse(match.Value.Substring(1), CultureInfo.InvariantCulture);
+            var currentArguments = string.Join(",", genericArguments.Take(currentGenericArgumentNumbers).Select(ToGenericTypeString));
+            genericArguments = genericArguments.Skip(currentGenericArgumentNumbers).ToArray();
+            return string.Concat("<", currentArguments, ">");
+        });
 
-            typeName = GenericArgumentsRegex.Replace(typeName, match =>
-            {
-                var currentGenericArgumentNumbers = int.Parse(match.Value.Substring(1), CultureInfo.InvariantCulture);
-                var currentArguments = string.Join(",", genericArguments.Take(currentGenericArgumentNumbers).Select(ToGenericTypeString));
-                genericArguments = genericArguments.Skip(currentGenericArgumentNumbers).ToArray();
-                return string.Concat("<", currentArguments, ">");
-            });
-
-            return typeName;
-        }
+        return typeName;
     }
+}

From d0dbb8bdd1ccc62501955aa12f7f0f977f681684 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 14:53:08 -0500
Subject: [PATCH 38/48] reformat code with dotnet format

---
 .../CustomTestException.cs                                | 2 +-
 .../HangfireQueueLatencyTests.cs                          | 8 ++++----
 .../Utils/MetricCollectionExtensions.cs                   | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
index 6a2f1752a8..5b77c859c8 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/CustomTestException.cs
@@ -1,4 +1,4 @@
-// Copyright The OpenTelemetry Authors
+// Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Tests;
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
index 7a98336d2f..9013c81e8f 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/HangfireQueueLatencyTests.cs
@@ -254,11 +254,11 @@ public void Should_NOT_Register_PendingDurationFilter_When_Disabled()
         };
 
         // Act
-        using var instrumentation = new Implementation.HangfireMetricsInstrumentation(options);
+        using var instrumentation = new HangfireMetricsInstrumentation(options);
 
         // Verify no HangfirePendingDurationFilterAttribute is registered
         var pendingDurationFilterExists = GlobalJobFilters.Filters
-            .Any(f => f.Instance is Implementation.HangfirePendingDurationFilterAttribute);
+            .Any(f => f.Instance is HangfirePendingDurationFilterAttribute);
         Assert.False(pendingDurationFilterExists);
     }
 
@@ -272,11 +272,11 @@ public void Should_Register_PendingDurationFilter_When_Enabled()
         };
 
         // Act
-        using var instrumentation = new Implementation.HangfireMetricsInstrumentation(options);
+        using var instrumentation = new HangfireMetricsInstrumentation(options);
 
         // Verify HangfirePendingDurationFilterAttribute IS registered
         var pendingDurationFilterExists = GlobalJobFilters.Filters
-            .Any(f => f.Instance is Implementation.HangfirePendingDurationFilterAttribute);
+            .Any(f => f.Instance is HangfirePendingDurationFilterAttribute);
         Assert.True(pendingDurationFilterExists);
     }
 }
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs
index 1aa0beda7f..10bccf3107 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/Utils/MetricCollectionExtensions.cs
@@ -1,4 +1,4 @@
-// Copyright The OpenTelemetry Authors
+// Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
 using OpenTelemetry.Metrics;

From afd0b94c1b8fbe447368705614eb3d437ef09397 Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Tue, 18 Nov 2025 20:24:19 -0500
Subject: [PATCH 39/48] Make HangfireTests assembly not signed

---
 .../Implementation/HangfireMetrics.cs              | 14 +++++++-------
 .../OpenTelemetry.Instrumentation.Hangfire.csproj  |  6 ++++++
 ...Telemetry.Instrumentation.Hangfire.Tests.csproj |  2 ++
 3 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
index c5467354ad..79d03ed483 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/Implementation/HangfireMetrics.cs
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using System.Diagnostics.Metrics;
-using System.Reflection;
 using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Instrumentation.Hangfire.Implementation;
@@ -77,14 +76,15 @@ internal static class HangfireMetrics
             unit: "{workflows}",
             description: "The number of actively running workflows grouped by definition and the current state.");
 
-    internal static readonly Assembly Assembly = typeof(HangfireMetrics).Assembly;
-    internal static readonly AssemblyName AssemblyName = Assembly.GetName();
-    internal static readonly string MeterName = AssemblyName.Name!;
+    /// <summary>
+    /// Returns Hangfire metric name.
+    /// </summary>
+    internal static readonly string MeterName = Meter.Name;
 
-    private static readonly string InstrumentationVersion = Assembly.GetPackageVersion();
+    private static Meter? meter;
 
     /// <summary>
-    /// The meter instance for all Hangfire metrics.
+    /// Gets the meter instance for all Hangfire metrics.
     /// </summary>
-    private static readonly Meter Meter = new(MeterName, InstrumentationVersion);
+    private static Meter Meter => meter ??= new(typeof(HangfireMetrics).Assembly.GetName().Name, typeof(HangfireMetrics).Assembly.GetPackageVersion());
 }
diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj b/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj
index 1f3d8222e6..a306eced5e 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/OpenTelemetry.Instrumentation.Hangfire.csproj
@@ -5,6 +5,7 @@
     <Description>OpenTelemetry Hangfire Instrumentation.</Description>
     <PackageTags>$(PackageTags);Hangfire</PackageTags>
     <MinVerTagPrefix>Instrumentation.Hangfire-</MinVerTagPrefix>
+    <SignAssembly>false</SignAssembly>
   </PropertyGroup>
 
   <!-- Do not run Package Baseline Validation as this package has never released a stable version.
@@ -21,6 +22,11 @@
     <PackageReference Include="OpenTelemetry.Api.ProviderBuilderExtensions" />
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Remove="$(AssemblyName).Tests" />
+    <InternalsVisibleTo Include="$(AssemblyName).Tests" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="$(RepoRoot)\src\Shared\AssemblyVersionExtensions.cs" Link="Includes\AssemblyVersionExtensions.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\Guard.cs" Link="Includes\Guard.cs" />
diff --git a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj
index d66cee4ff5..a12781ff1c 100644
--- a/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj
+++ b/test/OpenTelemetry.Instrumentation.Hangfire.Tests/OpenTelemetry.Instrumentation.Hangfire.Tests.csproj
@@ -5,6 +5,8 @@
     <TargetFrameworks>$(SupportedNetTargets)</TargetFrameworks>
     <TargetFrameworks Condition="$(OS) == 'Windows_NT'">$(TargetFrameworks);$(NetFrameworkMinimumSupportedVersion)</TargetFrameworks>
     <Description>Unit test project for OpenTelemetry Hangfire instrumentation.</Description>
+    <SignAssembly>false</SignAssembly>
+    <SkipStrongNameValidation>true</SkipStrongNameValidation>
   </PropertyGroup>
 
   <ItemGroup>

From 069423875e52d9242482f672aeff2ecdb2a491fe Mon Sep 17 00:00:00 2001
From: Oleksii Gorbach <gorbach.alexey@gmail.com>
Date: Wed, 19 Nov 2025 19:08:46 -0500
Subject: [PATCH 40/48] make lines in README.md shorter

---
 .../README.md                                 | 132 +++++++++++-------
 1 file changed, 79 insertions(+), 53 deletions(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 7564f7caef..30a8e27d82 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -166,8 +166,11 @@ using var tracerProvider = Sdk
 
 ## Metrics
 
-This instrumentation library collects metrics following a POC/draft definition of workflow metrics defined as part of [semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688).
-As those definitions evolve, changes including breaking ones will flow back to this implementation.
+This instrumentation library collects metrics following a POC/draft definition
+of workflow metrics defined as part of
+[semantic-conventions/#1688](https://github.com/open-telemetry/semantic-conventions/issues/1688).
+As those definitions evolve, changes including breaking ones will flow back
+to this implementation.
 
 In Hangfire, the workflow semantic conventions are applied as follows:
 
@@ -175,8 +178,8 @@ In Hangfire, the workflow semantic conventions are applied as follows:
 - Workflow-level metrics track the complete lifecycle (including scheduled jobs)
 - Execution-level metrics track the execution pipeline (enqueued jobs and later)
 
-This approach provides comprehensive visibility into both job creation/scheduling and
-actual execution performance.
+This approach provides comprehensive visibility into both job
+creation/scheduling and actual execution performance.
 
 ### Enabling Metrics
 
@@ -217,14 +220,16 @@ builder.Services.AddOpenTelemetry()
 
 ### Metrics Configuration
 
-Metrics behavior is configured through the `HangfireMetricsInstrumentationOptions` class
-in the `OpenTelemetry.Metrics` namespace.
+Metrics behavior is configured through the
+`HangfireMetricsInstrumentationOptions` class in the
+`OpenTelemetry.Metrics` namespace.
 
 #### RecordQueueLatency
 
-By default, the instrumentation records only the execution phase duration (time spent
-actually running the job). To also track the pending phase duration (time spent waiting
-in the queue before execution), enable the `RecordQueueLatency` option:
+By default, the instrumentation records only the execution phase duration
+(time spent actually running the job). To also track the pending phase
+duration (time spent waiting in the queue before execution), enable the
+`RecordQueueLatency` option:
 
 ```csharp
 var meterProvider = Sdk.CreateMeterProviderBuilder()
@@ -236,33 +241,37 @@ var meterProvider = Sdk.CreateMeterProviderBuilder()
     .Build();
 ```
 
-When enabled, `workflow.execution.duration` is recorded with `workflow.execution.state="pending"`
-representing queue wait time, in addition to `workflow.execution.state="executing"` for actual
-execution time.
+When enabled, `workflow.execution.duration` is recorded with
+`workflow.execution.state="pending"` representing queue wait time, in addition
+to `workflow.execution.state="executing"` for actual execution time.
 
 > [!WARNING]
-> Enabling `RecordQueueLatency` requires an additional database query per job execution
-> to retrieve the enqueue timestamp. In high-throughput scenarios, this may impact
-> performance.
-
+> Enabling `RecordQueueLatency` requires an additional database query per job
+> execution to retrieve the enqueue timestamp. In high-throughput scenarios,
+> this may impact performance.
+>
 > [!NOTE]
-> Add `using OpenTelemetry.Metrics;` to access `HangfireMetricsInstrumentationOptions`.
+> Add `using OpenTelemetry.Metrics;` to access
+> `HangfireMetricsInstrumentationOptions`.
 
 ### Available Metrics
 
 The following metrics are emitted by this instrumentation:
 
-**Execution-level metrics** track jobs that have entered the execution pipeline:
+**Execution-level metrics** track jobs that have entered the execution
+pipeline:
 
 - `workflow.execution.outcome` - Counter for completed executions
-- `workflow.execution.duration` - Histogram for execution duration (pending and executing phases)
+- `workflow.execution.duration` - Histogram for execution duration (pending
+  and executing phases)
 - `workflow.execution.status` - UpDownCounter for current execution state
 - `workflow.execution.errors` - Counter for execution errors
 
 **Workflow-level metrics** track the complete job lifecycle:
 
 - `workflow.outcome` - Counter for completed workflows
-- `workflow.status` - UpDownCounter for current workflow state (including scheduled jobs)
+- `workflow.status` - UpDownCounter for current workflow state (including
+  scheduled jobs)
 
 ---
 
@@ -275,8 +284,8 @@ The number of task executions which have been initiated.
 | `{executions}` | Counter         | `Int64`    |
 
 > [!NOTE]
-> This metric does NOT include the `workflow.execution.state` attribute, as state differentiation
-> is not needed for counting completed executions.
+> This metric does NOT include the `workflow.execution.state` attribute, as
+> state differentiation is not needed for counting completed executions.
 
 **Attributes:**
 
@@ -291,10 +300,11 @@ The number of task executions which have been initiated.
 
 #### workflow.execution.duration
 
-Duration of an execution grouped by task, state, and result. Records duration for different
-execution phases:
+Duration of an execution grouped by task, state, and result. Records duration
+for different execution phases:
 
-- **state=pending**: Time spent waiting in queue (only when `RecordQueueLatency` is enabled)
+- **state=pending**: Time spent waiting in queue (only when
+  `RecordQueueLatency` is enabled)
 - **state=executing**: Time spent in actual execution
 
 | Units | Instrument Type | Value Type |
@@ -302,9 +312,10 @@ execution phases:
 | `s`   | Histogram       | `Double`   |
 
 > [!NOTE]
-> The `workflow.execution.state` attribute is an extension to the current semantic conventions
-> to support measuring different execution phases (pending vs executing). This attribute is
-> being proposed for inclusion in the official semantic conventions.
+> The `workflow.execution.state` attribute is an extension to the current
+> semantic conventions to support measuring different execution phases
+> (pending vs executing). This attribute is being proposed for inclusion in
+> the official semantic conventions.
 
 **Attributes:**
 
@@ -327,8 +338,9 @@ The number of actively running tasks grouped by task and the current state.
 | `{executions}` | UpDownCounter    | `Int64`    |
 
 > [!NOTE]
-> This metric tracks the current state of job executions. When a job transitions
-> to a new state, the previous state is decremented and the new state is incremented.
+> This metric tracks the current state of job executions. When a job
+> transitions to a new state, the previous state is decremented and the new
+> state is incremented.
 
 **Attributes:**
 
@@ -397,9 +409,10 @@ The number of actively running workflows grouped by definition and the current s
 | `{workflows}`  | UpDownCounter    | `Int64`    |
 
 > [!NOTE]
-> This metric tracks the workflow lifecycle including jobs that haven't entered the execution
-> pipeline yet (e.g., scheduled jobs waiting for their trigger time). When a workflow transitions
-> to a new state, the previous state is decremented and the new state is incremented.
+> This metric tracks the workflow lifecycle including jobs that haven't
+> entered the execution pipeline yet (e.g., scheduled jobs waiting for their
+> trigger time). When a workflow transitions to a new state, the previous
+> state is decremented and the new state is incremented.
 
 **Attributes:**
 
@@ -428,16 +441,18 @@ Hangfire job states are mapped to workflow semantic convention states as follows
 > [!IMPORTANT]
 > **Difference between `workflow.status` and `workflow.execution.status`:**
 >
-> - **`workflow.status`**: Tracks the complete workflow lifecycle, including jobs that haven't
->   started execution yet (e.g., scheduled jobs waiting for their trigger time). This provides
->   visibility into jobs across all states.
+> - **`workflow.status`**: Tracks the complete workflow lifecycle, including
+>   jobs that haven't started execution yet (e.g., scheduled jobs waiting for
+>   their trigger time). This provides visibility into jobs across all states.
 >
-> - **`workflow.execution.status`**: Tracks only jobs that have entered the execution pipeline
->   (enqueued or later). Scheduled jobs do NOT appear here until they become enqueued.
+> - **`workflow.execution.status`**: Tracks only jobs that have entered the
+>   execution pipeline (enqueued or later). Scheduled jobs do NOT appear here
+>   until they become enqueued.
 >
-> For example, a scheduled job appears in `workflow.status{state=pending, trigger.type=schedule}`
-> but NOT in `workflow.execution.status` until it becomes enqueued. Once enqueued, it appears
-> in both metrics.
+> For example, a scheduled job appears in
+> `workflow.status{state=pending, trigger.type=schedule}` but NOT in
+> `workflow.execution.status` until it becomes enqueued. Once enqueued, it
+> appears in both metrics.
 
 ### Semantic Conventions
 
@@ -446,30 +461,41 @@ This instrumentation follows the OpenTelemetry semantic conventions for workflow
 #### Attribute Usage
 
 - **workflow.platform.name**: Always set to `"hangfire"`
-- **workflow.task.name** / **workflow.definition.name**: Derived from the Hangfire job method (e.g., `ClassName.MethodName`)
-  - `workflow.task.name` is used for execution-level metrics (`workflow.execution.*`)
-  - `workflow.definition.name` is used for workflow-level metrics (`workflow.outcome`, `workflow.status`)
+- **workflow.task.name** / **workflow.definition.name**: Derived from the
+  Hangfire job method (e.g., `ClassName.MethodName`)
+  - `workflow.task.name` is used for execution-level metrics
+    (`workflow.execution.*`)
+  - `workflow.definition.name` is used for workflow-level metrics
+    (`workflow.outcome`, `workflow.status`)
 - **workflow.trigger.type**: Identifies how the job was initiated
   - `"cron"` for recurring jobs
   - `"schedule"` for delayed jobs (scheduled for future execution)
   - `"api"` for fire-and-forget and continuation jobs
-  - Only included on workflow-level metrics (`workflow.outcome`, `workflow.status`), not on execution-level metrics (`workflow.execution.*`)
-- **workflow.execution.result** / **workflow.result**: Set to `"success"` when jobs complete without errors,
-  `"failure"` when an exception is thrown
-- **workflow.execution.state** / **workflow.state**: Maps Hangfire states to semantic convention states
-  - `workflow.execution.state` tracks execution pipeline states (used in `workflow.execution.status`, `workflow.execution.duration`)
-  - `workflow.state` tracks complete workflow lifecycle (used in `workflow.status`)
+  - Only included on workflow-level metrics (`workflow.outcome`,
+    `workflow.status`), not on execution-level metrics
+    (`workflow.execution.*`)
+- **workflow.execution.result** / **workflow.result**: Set to `"success"` when
+  jobs complete without errors, `"failure"` when an exception is thrown
+- **workflow.execution.state** / **workflow.state**: Maps Hangfire states to
+  semantic convention states
+  - `workflow.execution.state` tracks execution pipeline states (used in
+    `workflow.execution.status`, `workflow.execution.duration`)
+  - `workflow.state` tracks complete workflow lifecycle (used in
+    `workflow.status`)
   - See state mapping tables above for details
 - **error.type**: Set to the full type name of the exception when a job fails
 
 #### Workflow vs Execution Metrics
 
-The instrumentation distinguishes between **workflow-level** and **execution-level** metrics:
+The instrumentation distinguishes between **workflow-level** and
+**execution-level** metrics:
 
 **Workflow-level metrics** (`workflow.outcome`, `workflow.status`):
 
-- Track the complete lifecycle of jobs, including pre-execution states (e.g., scheduled)
-- Use `workflow.definition.name`, `workflow.state`, and `workflow.trigger.type`
+- Track the complete lifecycle of jobs, including pre-execution states (e.g.,
+  scheduled)
+- Use `workflow.definition.name`, `workflow.state`, and
+  `workflow.trigger.type`
 - Provide visibility into all jobs regardless of execution status
 
 **Execution-level metrics** (`workflow.execution.*`):

From 2872f357477a1e68086bf8b38534944cce5dfd6b Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:27:14 -0500
Subject: [PATCH 41/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 30a8e27d82..f73a550195 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -280,7 +280,7 @@ pipeline:
 The number of task executions which have been initiated.
 
 | Units          | Instrument Type | Value Type |
-|----------------|-----------------|------------|
+| -------------- | --------------- | ---------- |
 | `{executions}` | Counter         | `Int64`    |
 
 > [!NOTE]

From 9960ebd316e5c6f5c2b103d9c0df5c6ca19764f5 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:27:30 -0500
Subject: [PATCH 42/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index f73a550195..4817a9b578 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -290,7 +290,7 @@ The number of task executions which have been initiated.
 **Attributes:**
 
 | Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
-|-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
+| ----------------------------- | ------ | --------------------------------------------- | ------------------------ | ----------------------- |
 | `workflow.task.name`          | string | Name of the task (Hangfire job method)        | Required                 | e.g., `MyJob.Execute`   |
 | `workflow.execution.result`   | string | The result of executing the task              | Required                 | `success`, `failure`    |
 | `workflow.platform.name`      | string | The workflow platform being used              | Recommended              | `hangfire`              |

From 3b61b6a6bf18888f90b0b4683f07b6ef6215c959 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:27:42 -0500
Subject: [PATCH 43/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 4817a9b578..440b5342b5 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -308,7 +308,7 @@ for different execution phases:
 - **state=executing**: Time spent in actual execution
 
 | Units | Instrument Type | Value Type |
-|-------|-----------------|------------|
+| ----- | --------------- | ---------- |
 | `s`   | Histogram       | `Double`   |
 
 > [!NOTE]

From 422862c491e31e9251d265041e47fa8b1ca27dca Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:27:54 -0500
Subject: [PATCH 44/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 440b5342b5..8e0df8146f 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -358,7 +358,7 @@ The number of actively running tasks grouped by task and the current state.
 Hangfire job states are mapped to workflow semantic convention states as follows:
 
 | Hangfire State                     | Workflow State |
-|------------------------------------|----------------|
+| ---------------------------------- | -------------- |
 | Scheduled, Enqueued, Awaiting      | `pending`      |
 | Processing                         | `executing`    |
 | Succeeded, Failed, Deleted         | `completed`    |

From 00f1924b4e67be677561f37bee58492fd4ea1cd5 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:28:05 -0500
Subject: [PATCH 45/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index 8e0df8146f..ca561bb43e 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -391,7 +391,7 @@ individual job completions.
 **Attributes:**
 
 | Attribute                     | Type   | Description                                   | Requirement Level        | Values                  |
-|-------------------------------|--------|-----------------------------------------------|--------------------------|-------------------------|
+| ----------------------------- | ------ | --------------------------------------------- | ------------------------ | ----------------------- |
 | `workflow.definition.name`    | string | Name of the workflow (Hangfire job method)    | Required                 | e.g., `MyJob.Execute`   |
 | `workflow.result`             | string | The result of the workflow                    | Required                 | `success`, `failure`    |
 | `workflow.trigger.type`       | string | Type of trigger that initiated the workflow   | Required                 | `api`, `cron`, `schedule` |

From 2b19e59ec62ebb95629d4eeb01f86e60afe223ca Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:28:16 -0500
Subject: [PATCH 46/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index ca561bb43e..fbcd125c8b 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -385,7 +385,7 @@ The number of workflow instances which have been initiated. In Hangfire, this tr
 individual job completions.
 
 | Units          | Instrument Type | Value Type |
-|----------------|-----------------|------------|
+| -------------- | --------------- | ---------- |
 | `{workflows}`  | Counter         | `Int64`    |
 
 **Attributes:**

From aabc0a27e45ee630188e490ae4dd0ebc6a3bc291 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:28:29 -0500
Subject: [PATCH 47/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index fbcd125c8b..a796b82b48 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -405,7 +405,7 @@ individual job completions.
 The number of actively running workflows grouped by definition and the current state.
 
 | Units          | Instrument Type  | Value Type |
-|----------------|------------------|------------|
+| -------------- | ---------------- | ---------- |
 | `{workflows}`  | UpDownCounter    | `Int64`    |
 
 > [!NOTE]

From ac8dbfa2d9ef057a2c79091c8f06f43ba4e89f44 Mon Sep 17 00:00:00 2001
From: Gorbach Oleksii <gorbach.alexey@gmail.com>
Date: Thu, 20 Nov 2025 09:28:50 -0500
Subject: [PATCH 48/48] Update
 src/OpenTelemetry.Instrumentation.Hangfire/README.md

Co-authored-by: James Thompson <thompson.tomo@outlook.com>
---
 src/OpenTelemetry.Instrumentation.Hangfire/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/OpenTelemetry.Instrumentation.Hangfire/README.md b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
index a796b82b48..122bc42df8 100644
--- a/src/OpenTelemetry.Instrumentation.Hangfire/README.md
+++ b/src/OpenTelemetry.Instrumentation.Hangfire/README.md
@@ -431,7 +431,7 @@ The number of actively running workflows grouped by definition and the current s
 Hangfire job states are mapped to workflow semantic convention states as follows:
 
 | Hangfire State                     | Workflow State | Workflow Trigger Type           |
-|------------------------------------|----------------|---------------------------------|
+| ---------------------------------- | -------------- | ------------------------------- |
 | Scheduled                          | `pending`      | `schedule`                      |
 | Enqueued, Awaiting (from cron)     | `pending`      | `cron`                          |
 | Enqueued, Awaiting (fire-and-forget)| `pending`     | `api`                           |