(name: string, options?: SpanOptions): <A, E, R>(
self: Layer<A, E, R>
) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
<A, E, R>(
self: Layer<A, E, R>,
name: string,
options?: SpanOptions
): Layer<A, E, Exclude<R, Tracer.ParentSpan>>Wraps a Layer with a new tracing span, making all operations in the layer
constructor part of the named trace span.
Details
This creates a new span for the layer's construction and execution. The span is automatically ended when the layer's scope is closed. This is useful for tracking the lifecycle and performance of layer initialization.
Example (Wrapping a layer with a span)
import { Context, Effect, Layer } from "effect"
class Database extends Context.Service<Database, {
readonly query: (sql: string) => Effect.Effect<string>
}>()("Database") {}
class Logger extends Context.Service<Logger, {
readonly log: (msg: string) => Effect.Effect<void>
}>()("Logger") {}
// Create layers with tracing
const databaseLayer = Layer.effect(Database, Effect.gen(function*() {
yield* Effect.log("Connecting to database")
yield* Effect.sleep("100 millis")
return {
query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
}
})).pipe(Layer.withSpan("database-initialization", {
attributes: { dbType: "postgres" }
}))
const loggerLayer = Layer.succeed(Logger, {
log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
}).pipe(Layer.withSpan("logger-initialization"))
// Combine traced layers
const appLayer = Layer.mergeAll(databaseLayer, loggerLayer).pipe(
Layer.withSpan("app-initialization", {
onEnd: (span, exit) =>
Effect.sync(() => {
console.log(`Application initialization completed: ${exit._tag}`)
})
})
)
const program = Effect.gen(function*() {
const database = yield* Database
const logger = yield* Logger
yield* logger.log("Application ready")
return yield* database.query("SELECT * FROM users")
}).pipe(Effect.provide(appLayer))tracing
Source effect/Layer.ts:262743 lines
export const const withSpan: {
(name: string, options?: SpanOptions): <
A,
E,
R
>(
self: Layer<A, E, R>
) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
<A, E, R>(
self: Layer<A, E, R>,
name: string,
options?: SpanOptions
): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
}
Wraps a Layer with a new tracing span, making all operations in the layer
constructor part of the named trace span.
Details
This creates a new span for the layer's construction and execution. The span
is automatically ended when the layer's scope is closed. This is useful for
tracking the lifecycle and performance of layer initialization.
Example (Wrapping a layer with a span)
import { Context, Effect, Layer } from "effect"
class Database extends Context.Service<Database, {
readonly query: (sql: string) => Effect.Effect<string>
}>()("Database") {}
class Logger extends Context.Service<Logger, {
readonly log: (msg: string) => Effect.Effect<void>
}>()("Logger") {}
// Create layers with tracing
const databaseLayer = Layer.effect(Database, Effect.gen(function*() {
yield* Effect.log("Connecting to database")
yield* Effect.sleep("100 millis")
return {
query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
}
})).pipe(Layer.withSpan("database-initialization", {
attributes: { dbType: "postgres" }
}))
const loggerLayer = Layer.succeed(Logger, {
log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
}).pipe(Layer.withSpan("logger-initialization"))
// Combine traced layers
const appLayer = Layer.mergeAll(databaseLayer, loggerLayer).pipe(
Layer.withSpan("app-initialization", {
onEnd: (span, exit) =>
Effect.sync(() => {
console.log(`Application initialization completed: ${exit._tag}`)
})
})
)
const program = Effect.gen(function*() {
const database = yield* Database
const logger = yield* Logger
yield* logger.log("Application ready")
return yield* database.query("SELECT * FROM users")
}).pipe(Effect.provide(appLayer))
withSpan: {
(
name: stringname: string,
options: SpanOptionsoptions?: SpanOptions
): <function (type parameter) A in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>A, function (type parameter) E in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>E, function (type parameter) R in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>R>(
self: Layer<A, E, R>(parameter) self: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<A>, E, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<function (type parameter) A in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>A, function (type parameter) E in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>E, function (type parameter) R in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>R>
) => interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<function (type parameter) A in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>A, function (type parameter) E in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>E, type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) R in <A, E, R>(self: Layer<A, E, R>): Layer<A, E, Exclude<R, Tracer.ParentSpan>>R, import TracerTracer.class ParentSpanclass ParentSpan {
Service: Service;
key: Identifier;
}
Context service containing the Span or ExternalSpan to use as the parent
of newly-created child spans.
Example (Accessing the parent span)
import { Effect, Tracer } from "effect"
// Access the parent span from the context
const program = Effect.gen(function*() {
const parentSpan = yield* Effect.service(Tracer.ParentSpan)
console.log(`Parent span: ${parentSpan.spanId}`)
})
ParentSpan>>
<function (type parameter) A in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>A, function (type parameter) E in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>E, function (type parameter) R in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>R>(
self: Layer<A, E, R>(parameter) self: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<A>, E, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<function (type parameter) A in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>A, function (type parameter) E in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>E, function (type parameter) R in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>R>,
name: stringname: string,
options: SpanOptionsoptions?: SpanOptions
): interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<function (type parameter) A in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>A, function (type parameter) E in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>E, type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) R in <A, E, R>(self: Layer<A, E, R>, name: string, options?: SpanOptions): Layer<A, E, Exclude<R, Tracer.ParentSpan>>R, import TracerTracer.class ParentSpanclass ParentSpan {
Service: Service;
key: Identifier;
}
Context service containing the Span or ExternalSpan to use as the parent
of newly-created child spans.
Example (Accessing the parent span)
import { Effect, Tracer } from "effect"
// Access the parent span from the context
const program = Effect.gen(function*() {
const parentSpan = yield* Effect.service(Tracer.ParentSpan)
console.log(`Parent span: ${parentSpan.spanId}`)
})
ParentSpan>>
} = function() {
const const dataFirst: booleandataFirst = typeof function (local var) arguments: IArgumentsarguments[0] !== "string"
const const name: anyname = const dataFirst: booleandataFirst ? function (local var) arguments: IArgumentsarguments[1] : function (local var) arguments: IArgumentsarguments[0]
const const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
import internalTracerinternalTracer.const addSpanStackTrace: <
A extends Tracer.TraceOptions
>(
options: A | undefined
) => A
const dataFirst: booleandataFirst ? function (local var) arguments: IArgumentsarguments[2] : function (local var) arguments: IArgumentsarguments[1]) as SpanOptions
if (const dataFirst: booleandataFirst) {
const const self: anyself = function (local var) arguments: IArgumentsarguments[0]
return const unwrap: <A, E1, R1, E, R>(
self: Effect<Layer<A, E1, R1>, E, R>
) => Layer<
A,
E | E1,
R1 | Exclude<R, Scope.Scope>
>
Unwraps a Layer from an Effect, flattening the nested structure.
When to use
Use when you have an Effect that produces a Layer and you want to
use that layer directly.
Details
The resulting Layer will have the combined error and dependency types from
both the outer Effect and the inner Layer.
Example (Unwrapping an effectful layer)
import { Context, Effect, Layer } from "effect"
class Database extends Context.Service<Database, {
readonly query: (sql: string) => Effect.Effect<string>
}>()("Database") {}
const layerEffect = Effect.succeed(
Layer.succeed(Database, { query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result")) })
)
const unwrappedLayer = Layer.unwrap(layerEffect)
unwrap(
import internalEffectinternalEffect.const map: {
<A, B>(f: (a: A) => B): <E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<B, E, R>
<A, E, R, B>(
self: Effect.Effect<A, E, R>,
f: (a: A) => B
): Effect.Effect<B, E, R>
}
const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
SpanOptions.onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefinedRuns when the span associated with the layer ends, which happens when the
layer scope is closed.
onEnd !== var undefinedundefined
? import internalEffectinternalEffect.const tap: {
<A, B, E2, R2>(
f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
): <E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<A, E | E2, R | R2>
<B, E2, R2>(f: Effect.Effect<B, E2, R2>): <
A,
E,
R
>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<A, E | E2, R | R2>
<A, E, R, B, E2, R2>(
self: Effect.Effect<A, E, R>,
f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
): Effect.Effect<A, E | E2, R | R2>
<A, E, R, B, E2, R2>(
self: Effect.Effect<A, E, R>,
f: Effect.Effect<B, E2, R2>
): Effect.Effect<A, E | E2, R | R2>
}
import internalEffectinternalEffect.const makeSpanScoped: (
name: string,
options?: Tracer.SpanOptionsNoTrace | undefined
) => Effect.Effect<
Tracer.Span,
never,
Scope.Scope
>
const name: anyname, const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}
import internalEffectinternalEffect.const addFinalizer: <R>(
finalizer: (
exit: Exit.Exit<unknown, unknown>
) => Effect.Effect<void, never, R>
) => Effect.Effect<void, never, R | Scope.Scope>
exit: Exit.Exit<unknown, unknown>exit) => const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
SpanOptions.onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefinedRuns when the span associated with the layer ends, which happens when the
layer scope is closed.
onEnd!(span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}
exit: Exit.Exit<unknown, unknown>exit))
)
: import internalEffectinternalEffect.const makeSpanScoped: (
name: string,
options?: Tracer.SpanOptionsNoTrace | undefined
) => Effect.Effect<
Tracer.Span,
never,
Scope.Scope
>
const name: anyname, const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}
const withParentSpan: {
(
span: Tracer.AnySpan,
options?: Tracer.TraceOptions
): <A, E, R>(
self: Layer<A, E, R>
) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
<A, E, R>(
self: Layer<A, E, R>,
span: Tracer.AnySpan,
options?: Tracer.TraceOptions
): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
}
const self: anyself, span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}
self: Layer<any, any, any>(parameter) self: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<any>, any, any>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<any, any, any>) =>
const unwrap: <A, E1, R1, E, R>(
self: Effect<Layer<A, E1, R1>, E, R>
) => Layer<
A,
E | E1,
R1 | Exclude<R, Scope.Scope>
>
Unwraps a Layer from an Effect, flattening the nested structure.
When to use
Use when you have an Effect that produces a Layer and you want to
use that layer directly.
Details
The resulting Layer will have the combined error and dependency types from
both the outer Effect and the inner Layer.
Example (Unwrapping an effectful layer)
import { Context, Effect, Layer } from "effect"
class Database extends Context.Service<Database, {
readonly query: (sql: string) => Effect.Effect<string>
}>()("Database") {}
const layerEffect = Effect.succeed(
Layer.succeed(Database, { query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result")) })
)
const unwrappedLayer = Layer.unwrap(layerEffect)
unwrap(
import internalEffectinternalEffect.const map: {
<A, B>(f: (a: A) => B): <E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<B, E, R>
<A, E, R, B>(
self: Effect.Effect<A, E, R>,
f: (a: A) => B
): Effect.Effect<B, E, R>
}
const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
SpanOptions.onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefinedRuns when the span associated with the layer ends, which happens when the
layer scope is closed.
onEnd !== var undefinedundefined
? import internalEffectinternalEffect.const tap: {
<A, B, E2, R2>(
f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
): <E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<A, E | E2, R | R2>
<B, E2, R2>(f: Effect.Effect<B, E2, R2>): <
A,
E,
R
>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<A, E | E2, R | R2>
<A, E, R, B, E2, R2>(
self: Effect.Effect<A, E, R>,
f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
): Effect.Effect<A, E | E2, R | R2>
<A, E, R, B, E2, R2>(
self: Effect.Effect<A, E, R>,
f: Effect.Effect<B, E2, R2>
): Effect.Effect<A, E | E2, R | R2>
}
import internalEffectinternalEffect.const makeSpanScoped: (
name: string,
options?: Tracer.SpanOptionsNoTrace | undefined
) => Effect.Effect<
Tracer.Span,
never,
Scope.Scope
>
const name: anyname, const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}
import internalEffectinternalEffect.const addFinalizer: <R>(
finalizer: (
exit: Exit.Exit<unknown, unknown>
) => Effect.Effect<void, never, R>
) => Effect.Effect<void, never, R | Scope.Scope>
exit: Exit.Exit<unknown, unknown>exit) => const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
SpanOptions.onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefinedRuns when the span associated with the layer ends, which happens when the
layer scope is closed.
onEnd!(span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}
exit: Exit.Exit<unknown, unknown>exit))
)
: import internalEffectinternalEffect.const makeSpanScoped: (
name: string,
options?: Tracer.SpanOptionsNoTrace | undefined
) => Effect.Effect<
Tracer.Span,
never,
Scope.Scope
>
const name: anyname, const options: SpanOptionsconst options: {
onEnd: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect<void>) | undefined;
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}
const withParentSpan: {
(
span: Tracer.AnySpan,
options?: Tracer.TraceOptions
): <A, E, R>(
self: Layer<A, E, R>
) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
<A, E, R>(
self: Layer<A, E, R>,
span: Tracer.AnySpan,
options?: Tracer.TraceOptions
): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
}
self: Layer<any, any, any>(parameter) self: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<any>, any, any>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
span: Tracer.Span(parameter) span: {
_tag: "Span";
name: string;
spanId: string;
traceId: string;
parent: Option.Option<AnySpan>;
annotations: Context.Context<never>;
status: SpanStatus;
attributes: ReadonlyMap<string, unknown>;
links: ReadonlyArray<SpanLink>;
sampled: boolean;
kind: SpanKind;
end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void;
attribute: (key: string, value: unknown) => void;
event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void;
addLinks: (links: ReadonlyArray<SpanLink>) => void;
}