Trace workflows and inspect them in Aspire

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

Provides APIs to create and start objects and to register objects to listen to the events.

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'. Basic Types

Structural greater-than The first parameter. The second parameter. The result of the comparison. 5 > 1 // Evaluates to true 5 > 5 // Evaluates to false (1, "a") > (1, "z") // Evaluates to false

Creates a successful synchronous flow. The value to wrap in a successful flow. A flow that always succeeds with the provided value.

Same as error. The error value to wrap in a failing flow. A flow that always fails with the provided error. let result = Flow.fail "error" |> Flow.run () // result = Failure (Cause.Fail "error")

An abbreviation for the CLI type . Basic Types

Immutable maps based on binary trees, where keys are ordered by F# generic comparison. By default comparison is the F# structural comparison function or uses implementations of the IComparable interface on key values. See the module for further operations on maps. All members of this class are thread-safe and may be used concurrently from multiple threads.

The type of immutable singly-linked lists. See the module for further operations related to lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1; 2; 3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly. See also F# Language Guide - Lists.

Initializes a new instance of the class that is empty and has the default initial capacity.

Allows listening to the start and stop activity events and gives the opportunity to decide creating an activity for sampling scenarios.

Gets or sets the callback that allows deciding if activity object events that were created using the activity source object should be listened or not. to listen events; otherwise.

Returns the activity source name. A string that represents the activity source name.

Structural equality The first parameter. The second parameter. The result of the comparison. 5 = 5 // Evaluates to true 5 = 6 // Evaluates to false [1; 2] = [1; 2] // Evaluates to true (1, 5) = (1, 6) // Evaluates to false

Gets or sets the callback that is used to decide if creating objects with a specific data state is allowed. A sample activity instance.

A delegate that defines the signature of the callbacks used in the sampling process. The Activity creation options used by callbacks to decide creating the Activity object or not. The type of the requested parent to create the Activity object with. Should be either a string or an instance. An object containing the sampling results, which indicate the amount of data to collect for the related .

A representation that conforms to the W3C TraceContext specification. It contains two identifiers: a TraceId and a SpanId, along with a set of common TraceFlags and system-specific TraceState values.

Enumeration values used by to indicate the amount of data to collect for the related . Requesting more data causes a greater performance overhead.

The activity object should be populated with all the propagation information and also all other properties such as Links, Tags, and Events. Using this value causes to return .

Gets or sets the callback used to listen to the activity stop event. An activity callback instance used to listen to the activity stop event.

Gets the list of tags that represent information to log along with the activity. This information is not passed on to the children of this activity. A key-value pair enumeration of tags and objects.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Contains operations for working with values of type .

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The given function will be applied as elements are demanded using the MoveNext method on enumerators retrieved from the object. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence. A function to transform items from the input sequence. The input sequence. The result sequence. Thrown when the input sequence is null. let inputs = ["a"; "bbb"; "cc"] inputs |> Seq.map (fun x -> x.Length) Evaluates to a sequence yielding the same results as seq { 1; 3; 2 }

Gets the key in the key/value pair. A that is the key of the .

Converts the argument to a string using ToString. For standard integer and floating point values and any type that implements IFormattable, ToString conversion uses CultureInfo.InvariantCulture. The input value. The converted string. string 'A' // evaluates to "A" string 0xff // evaluates to "255" string -10 // evaluates to "-10"

Gets the value in the key/value pair. A that is the value of the .

Contains operations for working with values of type .

Returns a new map made from the given bindings. The input sequence of key/value pairs. The resulting map. This is an O(n log n) operation, where n is the number of elements in the sequence. let input = seq { (1, "a"); (2, "b") } input |> Map.ofSeq // evaluates to map [(1, "a"); (2, "b")]

Execute the function as a mutual-exclusion region using the input value as a lock. The object to be locked. The action to perform during the lock. The resulting value. open System.Linq /// A counter object, supporting unlocked and locked increment type TestCounter () = let mutable count = 0 /// Increment the counter, unlocked member this.IncrementWithoutLock() = count <- count + 1 /// Increment the counter, locked member this.IncrementWithLock() = lock this (fun () -> count <- count + 1) /// Get the count member this.Count = count let counter = TestCounter() // Create a parallel sequence to that uses all our CPUs (seq {1..100000}).AsParallel() .ForAll(fun _ -> counter.IncrementWithoutLock()) // Evaluates to a number between 1-100000, non-deterministically because there is no locking counter.Count let counter2 = TestCounter() // Create a parallel sequence to that uses all our CPUs (seq {1..100000}).AsParallel() .ForAll(fun _ -> counter2.IncrementWithLock()) // Evaluates to 100000 deterministically because the increment to the counter object is locked counter2.Count

Adds an object to the end of the . The object to be added to the end of the . The value can be for reference types.

Gets or sets the display name of the activity. A string that represents the activity display name.

Adds a listener to the activity starting and stopping events. The activity listener object to use for listening to the activity events.

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Ignore the passed value. This is often used to throw away results of a computation. The value to ignore. ignore 55555 // Evaluates to ()

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new list from the given enumerable object. The input sequence. The list of elements from the sequence. let inputs = seq { 1; 2; 5 } inputs |> List.ofSeq Evaluates to [ 1; 2; 5 ]. This is an O(n) operation, where n is the length of the sequence.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Wraps a flow in a new activity from the supplied application-owned source, exports the ambient telemetry context, and stamps the final exit onto the span. The activity stops when the workflow settles, so span duration covers asynchronous work. On settle the span receives ActivityStatusCode from the exit, axial.flow.outcome (success/fail/die/interrupt), axial.flow.error for typed errors, OpenTelemetry exception.* tags for defects, axial.flow.interrupted for cancellation, and axial.flow.cause with the pretty-printed tree for composite causes. Register the source name with the host's OpenTelemetry tracing pipeline. Axial's automatic fiber spans continue to use the Axial source because they describe Axial runtime behavior. The application-owned activity source that emits the span. Renders typed errors for the axial.flow.error attribute. The name of the activity. The flow to trace. A flow that executes within the activity span.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ] This is an O(n) operation, where n is the length of the list.

Return the first element of a tuple, fst (a,b) = a. The input tuple. The first value. fst ("first", 2) // Evaluates to "first"

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Wraps a flow in an application-owned activity source, rendering typed errors without reflection. Errors are rendered with their own ToString, or by type name when that ToString needs reflection NativeAOT removed. Use traceWith to supply a renderer. The application-owned activity source that emits the span. The name of the activity. The flow to trace. A flow that executes within the activity span.

Creates values.

Captures an application-owned activity source. The application-owned activity source that emits application spans.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Wraps a flow in a span from this tracer's activity source, rendering typed errors with string. The name of the activity.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Wraps a flow in the ambient application tracer installed by withTracer, and renders typed errors with string. Throws if no ambient tracer is installed. Use traceOn to supply a source explicitly instead of relying on the ambient one.

Installs an application-owned as the ambient tracer for the scope of . trace and traceWith read this ambient tracer; child fibers forked within the scope inherit it. The application-owned tracer to install. The flow to run with the tracer installed.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ] This is an O(n) operation, where n is the length of the list.

Return the first element of a tuple, fst (a,b) = a. The input tuple. The first value. fst ("first", 2) // Evaluates to "first"

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

Scopes the OpenTelemetry enduser.id span attribute around a workflow.

Wraps a flow in a new activity from the supplied application-owned source, exports the ambient telemetry context, and stamps the final exit onto the span. The activity stops when the workflow settles, so span duration covers asynchronous work. On settle the span receives ActivityStatusCode from the exit, axial.flow.outcome (success/fail/die/interrupt), axial.flow.error for typed errors, OpenTelemetry exception.* tags for defects, axial.flow.interrupted for cancellation, and axial.flow.cause with the pretty-printed tree for composite causes. Register the source name with the host's OpenTelemetry tracing pipeline. Axial's automatic fiber spans continue to use the Axial source because they describe Axial runtime behavior. The application-owned activity source that emits the span. Renders typed errors for the axial.flow.error attribute. The name of the activity. The flow to trace. A flow that executes within the activity span.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ] This is an O(n) operation, where n is the length of the list.

Contains operations for working with values of type .

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not. The input key. The input map. The found Some value or None. Maps are represented as binary trees so this is an O(log n) operation, where n is the number of bindings in the map. let sample = Map [ (1, "a"); (2, "b") ] sample |> Map.tryFind 1 // evaluates to Some "a" sample |> Map.tryFind 3 // evaluates to None

The representation of "Value of type 'T" The input value. An option representing the value.

Creates typed keys for application-defined telemetry attributes.

Creates a string-valued attribute key.

Creates a 64-bit integer-valued attribute key.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

Scopes telemetry attributes around a workflow.

Creates an application-defined attribute by pairing a typed key with a value.

Wraps a flow in a new activity from the supplied application-owned source, exports the ambient telemetry context, and stamps the final exit onto the span. The activity stops when the workflow settles, so span duration covers asynchronous work. On settle the span receives ActivityStatusCode from the exit, axial.flow.outcome (success/fail/die/interrupt), axial.flow.error for typed errors, OpenTelemetry exception.* tags for defects, axial.flow.interrupted for cancellation, and axial.flow.cause with the pretty-printed tree for composite causes. Register the source name with the host's OpenTelemetry tracing pipeline. Axial's automatic fiber spans continue to use the Axial source because they describe Axial runtime behavior. The application-owned activity source that emits the span. Renders typed errors for the axial.flow.error attribute. The name of the activity. The flow to trace. A flow that executes within the activity span.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ] This is an O(n) operation, where n is the length of the list.

Contains operations for working with values of type .

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not. The input key. The input map. The found Some value or None. Maps are represented as binary trees so this is an O(log n) operation, where n is the number of bindings in the map. let sample = Map [ (1, "a"); (2, "b") ] sample |> Map.tryFind 1 // evaluates to Some "a" sample |> Map.tryFind 3 // evaluates to None

The representation of "Value of type 'T" The input value. An option representing the value.

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

An empty telemetry context.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Adds the OpenTelemetry enduser.id span attribute to a context.

Adds or replaces one attribute.

Creates an application-defined attribute by pairing a typed key with a value.

Scopes a telemetry context around a workflow.

An immutable set of telemetry attributes propagated with a running workflow.

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

Reads a typed attribute from a context.

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'. Basic Types

An abbreviation for the CLI type . Basic Types

The type of optional values. When used from other CLI languages the empty option is the null value. Use the constructors Some and None to create values of this type. Use the values in the Option module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value null to other CLI languages. Instance methods on this type will appear as static methods to other CLI languages due to the use of null as a value representation. Options

The universal flow { } computation expression.

Reads the currently scoped telemetry context.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Scopes a telemetry context around a workflow.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow completed successfully.

The representation of "Value of type 'T" The input value. An option representing the value.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the defect-only telemetry fiber observer, typically once at the application edge. The source flow. A flow whose forked fibers report defects through the installed tracer.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the span-per-fiber telemetry observer: every forked fiber becomes an axial.flow.fiber span covering fork to settle. See observerWithSpans. The source flow. A flow whose forked fibers each produce a span on the installed tracer.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

OpenTelemetry-compatible fiber runtime metrics on the Axial meter. Register the meter with your OpenTelemetry pipeline (AddMeter("Axial")) and every metric appears in any OTLP backend, including the Aspire dashboard's metrics view. Instruments: axial.flow.fibers.started and axial.flow.fibers.settled (counters; settled is tagged with axial.flow.fiber.status), axial.flow.fibers.live (up-down counter), axial.flow.fiber.duration (histogram, seconds, tagged with status), and axial.flow.fibers.unobserved_defects (counter).

Installs the metrics fiber observer on a flow, composing with any observer already installed, typically once at the application edge, stacked with FiberTelemetry.observe or a FiberRegistry. The source flow. A flow whose forked fibers report runtime metrics on the Axial meter.

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the defect-only telemetry fiber observer, typically once at the application edge. The source flow. A flow whose forked fibers report defects through the installed tracer.

Broadcasts every published value to every current subscription. Create one with Hub.make. Use a hub when there can be zero or many consumers. The type of the published values.

An abbreviation for the CLI type . Basic Types

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'. Basic Types

Represents an error channel that cannot occur.

The universal flow { } computation expression.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Creates hubs, publishes to them, and subscribes to them. A publish reaches every subscription that exists when it starts; a subscriber sees only values published after its subscribe completes, so a late joiner that needs current state must get it elsewhere, for example from a SubscriptionRef. Publishes are serialized, so every subscriber observes values in the same order even with concurrent publishers. Dropping, Sliding, and Unbounded subscriptions never delay the publisher. A BackPressure subscription with a full buffer suspends publish until it has room or its subscription ends. While the publisher waits, no later value reaches any subscriber, lossy ones included: keeping one order for every subscriber means a stalled lossless subscriber stalls the feed. Size a lossless subscriber's buffer for the bursts you expect, watch Dequeue.size to raise an alarm before it fills, and use Hub.tryPublish where the publisher must never wait. Shutting a hub down shuts every subscription down with Dequeue.shutdown semantics: subscribers drain their backlog, streams over subscriptions end normally, and later publishes are interrupted.

Subscribes to the hub with a buffering strategy. The subscription ends when the current scope closes. Run subscribe inside Flow.scoped, a forked fiber, or an application root: a forked fiber's subscription ends with the fiber. Ending the subscription, by closing its scope or with Dequeue.shutdown, removes it from the hub and releases a publisher waiting on it. To subscribe for the life of a stream, use FlowStream.fromHub. flow { let! (readings: Hub<float>) = Hub.make () let! latest = readings |> Hub.subscribe (QueueStrategy.Sliding 1) do! readings |> Hub.publishAll [ 20.0; 21.5 ] |> Flow.ignore return! Dequeue.takeAll latest } |> Flow.scoped

What a queue, or a hub subscription, does with a value offered while it is full. Lossless delivery needs either back-pressure or unbounded memory. BackPressure keeps every value by making the producer wait; Unbounded keeps every value by growing without limit; Dropping and Sliding never make the producer wait and lose values instead. A non-positive capacity fails the flow that uses the strategy with a defect.

Lossless. A full buffer suspends the producer until a value is taken.

OpenTelemetry-compatible queue and hub-subscription metrics on the Axial meter. Register a queue, or a hub subscription, under a name with QueueMetrics.observe. Its figures are read only when the metrics pipeline collects, so observing a queue adds no cost to offers and takes. Every measurement is tagged with axial.queue.name. Instruments: axial.queue.size, axial.queue.capacity (bounded queues only), axial.queue.waiting_takers, and axial.queue.waiting_offerers (gauges); and axial.queue.accepted, axial.queue.dropped, and axial.queue.evicted (counters). Alert on axial.queue.size approaching axial.queue.capacity for a lossless subscriber, before it fills and holds up the publisher, and on the rate of axial.queue.dropped or axial.queue.evicted for a lossy one.

Reports a queue's metrics under until the current scope closes. Works for a Queue and for a hub subscription, which is a Dequeue. Run it in the scope that owns the queue, such as the fiber that consumes a subscription, so the queue stops being reported when that scope ends. The value of the axial.queue.name tag. The queue or subscription to report. flow { let! history = readings |> Hub.subscribe (QueueStrategy.BackPressure 10_000) do! history |> QueueMetrics.observe "historian" do! history |> FlowStream.fromDequeue |> FlowStream.runForEachFlow record }

Creates a stream that takes values from a queue or hub subscription until it is shut down and drained. Shutdown is the normal end of the stream, not a failure: after Dequeue.shutdown or Hub.shutdown the stream emits the remaining backlog and then completes. Each pull suspends while the queue is empty. Interrupting a pull leaves any value it would have received in the queue. flow { let! (jobs: Queue<string>) = Queue.bounded 8 do! jobs |> Queue.offerAll [ "a"; "b" ] |> Flow.ignore do! Dequeue.shutdown jobs return! jobs |> FlowStream.fromDequeue |> FlowStream.runCollect }

Runs an effectful action for every stream value. stream |> FlowStream.runForEachFlow save

Creates a registry that remembers the last 200 settled fibers and unobserved defects.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Tracks every fiber forked inside the flow in . The registry's observer is composed with any observer already installed, so telemetry hooks and the registry can coexist from separate installs. Install once at the application edge, keep the registry, and call registry.DumpAt(clock) (or registry.Snapshot()) whenever a live fiber tree is needed. The registry that receives fiber lifecycle events. The source flow. A flow whose forked fibers are tracked in the registry.

OpenTelemetry-compatible fiber runtime metrics on the Axial meter. Register the meter with your OpenTelemetry pipeline (AddMeter("Axial")) and every metric appears in any OTLP backend, including the Aspire dashboard's metrics view. Instruments: axial.flow.fibers.started and axial.flow.fibers.settled (counters; settled is tagged with axial.flow.fiber.status), axial.flow.fibers.live (up-down counter), axial.flow.fiber.duration (histogram, seconds, tagged with status), and axial.flow.fibers.unobserved_defects (counter).

Installs the metrics fiber observer on a flow, composing with any observer already installed, typically once at the application edge, stacked with FiberTelemetry.observe or a FiberRegistry. The source flow. A flow whose forked fibers report runtime metrics on the Axial meter.

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the defect-only telemetry fiber observer, typically once at the application edge. The source flow. A flow whose forked fibers report defects through the installed tracer.

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

An environment containing only a clock, for timed flows with no other services.

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'. Basic Types

Suspends the flow for the specified duration, observing cancellation. The duration to sleep. A flow that completes after the specified delay, or is interrupted if cancelled first.

Represents a time interval.

Returns a that represents a specified number of seconds, where the specification is accurate to the nearest millisecond. A number of seconds, accurate to the nearest millisecond. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Represents a handle to a workflow that has already been started. A fiber is the hot counterpart to a cold Flow, returned by Flow.fork. Wait for it with Fiber.join (its value, re-raising its failure) or Fiber.await (its Exit), check it with Fiber.poll, and stop it with Fiber.interrupt. The failure type of the running workflow. The success type of the running workflow.

Starts a flow in a new fiber carrying a diagnostic name. The name appears in FiberDump snapshots, FiberRegistry dumps, and telemetry fiber spans, so long-lived background fibers are recognizable in diagnostics instead of showing as bare ids. The diagnostic name recorded in the fiber's metadata. The flow to fork. A flow that produces a handle.

Exports structured fiber dumps into traces.

Records the registry's current live-fiber tree on the active trace: as an axial.flow.fiber.dump event on the current activity when one exists, otherwise as a standalone axial.flow.fiber.dump span. The event carries axial.flow.fibers.live and the rendered tree in axial.flow.fiber.dump.tree, so dumps land next to the traces they explain in any OTLP backend, including the Aspire dashboard. The registry to snapshot.

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.