<
const Loggers extends ReadonlyArray<
| Logger<unknown, unknown>
| Effect.Effect<Logger<unknown, unknown>, any, any>
>
>(
loggers: Loggers,
options?:
| { readonly mergeWithExisting?: boolean | undefined }
| undefined
): Layer.Layer<
never,
Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>,
Exclude<
Loggers extends readonly []
? never
: Effect.Services<Loggers[number]>,
Scope.Scope
>
>Creates a Layer which will overwrite the current set of loggers with the
specified array of loggers.
Details
If the specified array of loggers should be merged with the current set
of loggers (instead of overwriting them), set mergeWithExisting to true.
Example (Providing logger layers)
import { Effect, Logger } from "effect"
// Single logger layer
const JsonLoggerLive = Logger.layer([Logger.consoleJson])
// Multiple loggers layer
const MultiLoggerLive = Logger.layer([
Logger.consoleJson,
Logger.consolePretty(),
Logger.formatStructured
])
// Merge with existing loggers
const AdditionalLoggerLive = Logger.layer(
[Logger.consoleJson],
{ mergeWithExisting: true }
)
// Using multiple logger formats
const jsonLogger = Logger.consoleJson
const prettyLogger = Logger.consolePretty()
const CustomLoggerLive = Logger.layer([jsonLogger, prettyLogger])
const program = Effect.log("Application started").pipe(
Effect.provide(CustomLoggerLive)
)context
Source effect/Logger.ts:113023 lines
export const const layer: <
Loggers extends ReadonlyArray<
| Logger<unknown, unknown>
| Effect.Effect<
Logger<unknown, unknown>,
any,
any
>
>
>(
loggers: Loggers,
options?:
| {
readonly mergeWithExisting?:
| boolean
| undefined
}
| undefined
) => Layer.Layer<
never,
Loggers extends readonly []
? never
: Effect.Error<Loggers[number]>,
Exclude<
Loggers extends readonly []
? never
: Effect.Services<Loggers[number]>,
Scope.Scope
>
>
Creates a Layer which will overwrite the current set of loggers with the
specified array of loggers.
Details
If the specified array of loggers should be merged with the current set
of loggers (instead of overwriting them), set mergeWithExisting to true.
Example (Providing logger layers)
import { Effect, Logger } from "effect"
// Single logger layer
const JsonLoggerLive = Logger.layer([Logger.consoleJson])
// Multiple loggers layer
const MultiLoggerLive = Logger.layer([
Logger.consoleJson,
Logger.consolePretty(),
Logger.formatStructured
])
// Merge with existing loggers
const AdditionalLoggerLive = Logger.layer(
[Logger.consoleJson],
{ mergeWithExisting: true }
)
// Using multiple logger formats
const jsonLogger = Logger.consoleJson
const prettyLogger = Logger.consolePretty()
const CustomLoggerLive = Logger.layer([jsonLogger, prettyLogger])
const program = Effect.log("Application started").pipe(
Effect.provide(CustomLoggerLive)
)
layer = <
const function (type parameter) Loggers in <const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>>(loggers: Loggers, options?: {
readonly mergeWithExisting?: boolean | undefined;
} | undefined): Layer.Layer<never, Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>, Exclude<Loggers extends readonly [] ? never : Effect.Services<Loggers[number]>, Scope.Scope>>
interface ReadonlyArray<T>ReadonlyArray<interface Logger<in Message, out Output>A logger that transforms a runtime log event into an output value.
Details
The runtime calls log with the message, level, cause, fiber, and timestamp
for each log event. Use Logger.layer to install one or more loggers for an
effect.
Example (Creating custom loggers)
import { Effect, Logger } from "effect"
// Create a custom logger that accepts unknown messages and returns void
const stringLogger = Logger.make<unknown, void>((options) => {
console.log(`[${options.logLevel}] ${options.message}`)
})
// Create a logger that accepts any message type and returns a formatted string
const formattedLogger = Logger.make<unknown, string>((options) =>
`${options.date.toISOString()} [${options.logLevel}] ${options.message}`
)
// Use the logger in an Effect program
const program = Effect.log("Hello World").pipe(
Effect.provide(Logger.layer([stringLogger]))
)
Logger<unknown, unknown> | import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<interface Logger<in Message, out Output>A logger that transforms a runtime log event into an output value.
Details
The runtime calls log with the message, level, cause, fiber, and timestamp
for each log event. Use Logger.layer to install one or more loggers for an
effect.
Example (Creating custom loggers)
import { Effect, Logger } from "effect"
// Create a custom logger that accepts unknown messages and returns void
const stringLogger = Logger.make<unknown, void>((options) => {
console.log(`[${options.logLevel}] ${options.message}`)
})
// Create a logger that accepts any message type and returns a formatted string
const formattedLogger = Logger.make<unknown, string>((options) =>
`${options.date.toISOString()} [${options.logLevel}] ${options.message}`
)
// Use the logger in an Effect program
const program = Effect.log("Hello World").pipe(
Effect.provide(Logger.layer([stringLogger]))
)
Logger<unknown, unknown>, any, any>>
>(
loggers: const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>loggers: function (type parameter) Loggers in <const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>>(loggers: Loggers, options?: {
readonly mergeWithExisting?: boolean | undefined;
} | undefined): Layer.Layer<never, Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>, Exclude<Loggers extends readonly [] ? never : Effect.Services<Loggers[number]>, Scope.Scope>>
options: | {
readonly mergeWithExisting?:
| boolean
| undefined
}
| undefined
mergeWithExisting?: boolean | undefinedmergeWithExisting?: boolean | undefined } | undefined
): import LayerLayer.type Layer.Layer = /*unresolved*/ anyLayer<
never,
function (type parameter) Loggers in <const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>>(loggers: Loggers, options?: {
readonly mergeWithExisting?: boolean | undefined;
} | undefined): Layer.Layer<never, Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>, Exclude<Loggers extends readonly [] ? never : Effect.Services<Loggers[number]>, Scope.Scope>>
import EffectEffect.type Effect.Error = /*unresolved*/ anyError<function (type parameter) Loggers in <const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>>(loggers: Loggers, options?: {
readonly mergeWithExisting?: boolean | undefined;
} | undefined): Layer.Layer<never, Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>, Exclude<Loggers extends readonly [] ? never : Effect.Services<Loggers[number]>, Scope.Scope>>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<
function (type parameter) Loggers in <const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>>(loggers: Loggers, options?: {
readonly mergeWithExisting?: boolean | undefined;
} | undefined): Layer.Layer<never, Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>, Exclude<Loggers extends readonly [] ? never : Effect.Services<Loggers[number]>, Scope.Scope>>
import EffectEffect.type Effect.Services = /*unresolved*/ anyServices<function (type parameter) Loggers in <const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>>(loggers: Loggers, options?: {
readonly mergeWithExisting?: boolean | undefined;
} | undefined): Layer.Layer<never, Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>, Exclude<Loggers extends readonly [] ? never : Effect.Services<Loggers[number]>, Scope.Scope>>
import ScopeScope.Scope
>
> =>
import LayerLayer.effect(
const CurrentLoggers: Context.Reference<
ReadonlySet<Logger<unknown, any>>
>
const CurrentLoggers: {
key: string;
Service: {
forEach: (callbackfn: (value: Logger<unknown, any>, value2: Logger<unknown, any>, set: ReadonlySet<Logger<unknown, any>>) => void, thisArg?: any) => void;
has: (value: Logger<unknown, any>) => boolean;
size: number;
entries: () => SetIterator<[Logger<unknown, any>, Logger<unknown, any>]>;
keys: () => SetIterator<Logger<unknown, any>>;
values: () => SetIterator<Logger<unknown, any>>;
union: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any> | U>;
intersection: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any> & U>;
difference: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any>>;
symmetricDifference: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any> | U>;
isSubsetOf: (other: ReadonlySetLike<unknown>) => boolean;
isSupersetOf: (other: ReadonlySetLike<unknown>) => boolean;
isDisjointFrom: (other: ReadonlySetLike<unknown>) => boolean;
};
defaultValue: () => Shape;
of: (this: void, self: ReadonlySet<Logger<unknown, any>>) => ReadonlySet<Logger<unknown, any>>;
context: (self: ReadonlySet<Logger<unknown, any>>) => Context.Context<never>;
use: (f: (service: ReadonlySet<Logger<unknown, any>>) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
useSync: (f: (service: ReadonlySet<Logger<unknown, any>>) => A) => Effect.Effect<A, never, never>;
Identifier: Identifier;
stack: string | undefined;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
Context reference containing the active loggers for the current fiber.
Details
By default this set includes the default logger and the tracer logger.
Providing Logger.layer replaces or merges with this set depending on its
options.
Example (Accessing current loggers)
import { Effect, Logger } from "effect"
// Access current loggers from fiber context
const program = Effect.gen(function*() {
const currentLoggers = yield* Effect.service(Logger.CurrentLoggers)
console.log(`Number of active loggers: ${currentLoggers.size}`)
// Add a custom logger to the set
const customLogger = Logger.make((options) => {
console.log(`Custom: ${options.message}`)
})
yield* Effect.log("Hello from custom logger").pipe(
Effect.provide(Logger.layer([customLogger]))
)
})
CurrentLoggers,
withFiber<A, E = never, R = never>(evaluate: (fiber: effect.FiberImpl<unknown, unknown>) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>withFiber(import effecteffect.const fnUntraced: Effect.fn.UntracedfnUntraced(function*(fiber: any(parameter) fiber: {
id: number;
interruptible: boolean;
currentOpCount: number;
currentLoopCount: number;
_stack: Array<Primitive>;
_observers: Array<(exit: Exit.Exit<A, E>) => void>;
_exit: Exit.Exit<A, E> | undefined;
_currentExit: Exit.Exit<A, E> | undefined;
_children: Set<FiberImpl<any, any>> | undefined;
_interruptedCause: Cause.Cause<never> | undefined;
_yielded: Exit.Exit<any, any> | (() => void) | undefined;
context: Context.Context<never>;
currentScheduler: Scheduler.Scheduler;
currentTracerContext: Tracer.Tracer["context"];
currentSpan: Tracer.AnySpan | undefined;
currentLogLevel: LogLevel.LogLevel;
minimumLogLevel: LogLevel.LogLevel;
currentStackFrame: StackFrame | undefined;
runtimeMetrics: Metric.FiberRuntimeMetricsService | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
_dispatcher: Scheduler.SchedulerDispatcher | undefined;
currentDispatcher: SchedulerDispatcher;
getRef: <X>(ref: Context.Reference<X>) => X;
addObserver: (cb: (exit: Exit<unknown, unknown>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<unknown, unknown> | undefined;
evaluate: (effect: Primitive) => void;
runLoop: (effect: Primitive) => Exit<unknown, unknown> | typeof Yield;
getCont: <S extends contA | contE>(symbol: S) => (Primitive & Record<S, (value: any, fiber: effect.FiberImpl) => Primitive>) | undefined;
yieldWith: (value: Exit.Exit<any, any> | (() => void)) => Yield;
children: () => Set<Fiber.Fiber<any, any>>;
pipe: () => unknown;
setContext: (context: Context.Context<never>) => void;
currentSpanLocal: Span | undefined;
}
const currentLoggers: Set<
Logger<unknown, any>
>
var Set: SetConstructor
new <unknown>(iterable?: Iterable<unknown> | null | undefined) => Set<unknown> (+1 overload)
options: | {
readonly mergeWithExisting?:
| boolean
| undefined
}
| undefined
mergeWithExisting?: boolean | undefinedmergeWithExisting === true ? fiber: any(parameter) fiber: {
id: number;
interruptible: boolean;
currentOpCount: number;
currentLoopCount: number;
_stack: Array<Primitive>;
_observers: Array<(exit: Exit.Exit<A, E>) => void>;
_exit: Exit.Exit<A, E> | undefined;
_currentExit: Exit.Exit<A, E> | undefined;
_children: Set<FiberImpl<any, any>> | undefined;
_interruptedCause: Cause.Cause<never> | undefined;
_yielded: Exit.Exit<any, any> | (() => void) | undefined;
context: Context.Context<never>;
currentScheduler: Scheduler.Scheduler;
currentTracerContext: Tracer.Tracer["context"];
currentSpan: Tracer.AnySpan | undefined;
currentLogLevel: LogLevel.LogLevel;
minimumLogLevel: LogLevel.LogLevel;
currentStackFrame: StackFrame | undefined;
runtimeMetrics: Metric.FiberRuntimeMetricsService | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
_dispatcher: Scheduler.SchedulerDispatcher | undefined;
currentDispatcher: SchedulerDispatcher;
getRef: <X>(ref: Context.Reference<X>) => X;
addObserver: (cb: (exit: Exit<unknown, unknown>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<unknown, unknown> | undefined;
evaluate: (effect: Primitive) => void;
runLoop: (effect: Primitive) => Exit<unknown, unknown> | typeof Yield;
getCont: <S extends contA | contE>(symbol: S) => (Primitive & Record<S, (value: any, fiber: effect.FiberImpl) => Primitive>) | undefined;
yieldWith: (value: Exit.Exit<any, any> | (() => void)) => Yield;
children: () => Set<Fiber.Fiber<any, any>>;
pipe: () => unknown;
setContext: (context: Context.Context<never>) => void;
currentSpanLocal: Span | undefined;
}
import effecteffect.const CurrentLoggers: Context.Reference<
ReadonlySet<Logger<unknown, any>>
>
const CurrentLoggers: {
key: string;
Service: {
forEach: (callbackfn: (value: Logger<unknown, any>, value2: Logger<unknown, any>, set: ReadonlySet<Logger<unknown, any>>) => void, thisArg?: any) => void;
has: (value: Logger<unknown, any>) => boolean;
size: number;
entries: () => SetIterator<[Logger<unknown, any>, Logger<unknown, any>]>;
keys: () => SetIterator<Logger<unknown, any>>;
values: () => SetIterator<Logger<unknown, any>>;
union: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any> | U>;
intersection: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any> & U>;
difference: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any>>;
symmetricDifference: (other: ReadonlySetLike<U>) => Set<Logger<unknown, any> | U>;
isSubsetOf: (other: ReadonlySetLike<unknown>) => boolean;
isSupersetOf: (other: ReadonlySetLike<unknown>) => boolean;
isDisjointFrom: (other: ReadonlySetLike<unknown>) => boolean;
};
defaultValue: () => Shape;
of: (this: void, self: ReadonlySet<Logger<unknown, any>>) => ReadonlySet<Logger<unknown, any>>;
context: (self: ReadonlySet<Logger<unknown, any>>) => Context.Context<never>;
use: (f: (service: ReadonlySet<Logger<unknown, any>>) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
useSync: (f: (service: ReadonlySet<Logger<unknown, any>>) => A) => Effect.Effect<A, never, never>;
Identifier: Identifier;
stack: string | undefined;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const logger: anylogger of loggers: const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>loggers) {
const currentLoggers: Set<
Logger<unknown, any>
>
Set<unknown>.add(value: unknown): Set<unknown>Appends a new element with a specified value to the end of the Set.
add(function isEffect(u: unknown): u is Effect.Effect<any, any, any>isEffect(const logger: anylogger) ? yield* const logger: Effect.Effect<
Logger<unknown, unknown>,
any,
any
>
const logger: {
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const logger: Logger<unknown, unknown>const logger: {
log: (options: Options<unknown>) => unknown;
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; <…;
}
const currentLoggers: Set<
Logger<unknown, any>
>