(self: LogLevel): Effect.Effect<boolean>Checks whether a given log level is enabled for the current fiber.
When to use
Use to check whether a log level would be emitted under the current fiber's minimum log level.
Details
A log level is enabled when it is greater than or equal to
References.MinimumLogLevel.
Example (Checking current fiber log level)
import { Effect, LogLevel, References } from "effect"
const program = Effect.gen(function*() {
const debugEnabled = yield* LogLevel.isEnabled("Debug")
const errorEnabled = yield* LogLevel.isEnabled("Error")
console.log({ debugEnabled, errorEnabled })
})
const warnOnly = program.pipe(
Effect.provideService(References.MinimumLogLevel, "Warn")
)filtering
Source effect/LogLevel.ts:4112 lines
export const const isEnabled: (
self: LogLevel
) => Effect.Effect<boolean>
Checks whether a given log level is enabled for the current fiber.
When to use
Use to check whether a log level would be emitted under the current fiber's
minimum log level.
Details
A log level is enabled when it is greater than or equal to
References.MinimumLogLevel.
Example (Checking current fiber log level)
import { Effect, LogLevel, References } from "effect"
const program = Effect.gen(function*() {
const debugEnabled = yield* LogLevel.isEnabled("Debug")
const errorEnabled = yield* LogLevel.isEnabled("Error")
console.log({ debugEnabled, errorEnabled })
})
const warnOnly = program.pipe(
Effect.provideService(References.MinimumLogLevel, "Warn")
)
isEnabled = (self: LogLevelself: type LogLevel =
| "All"
| "Fatal"
| "Error"
| "Warn"
| "Info"
| "Debug"
| "Trace"
| "None"
Represents every level used by Effect logging, including concrete message
severities and the All and None sentinel levels.
When to use
Use to type values that may be either concrete log message severities or
logging configuration sentinels.
Details
The levels are ordered from most severe to least severe:
All - Special level that allows all messagesFatal - System is unusable, immediate attention requiredError - Error conditions that should be investigatedWarn - Warning conditions that may indicate problemsInfo - Informational messages about normal operationDebug - Debug information useful during developmentTrace - Very detailed trace informationNone - Special level that suppresses all messages
Example (Using log levels)
import { Effect } from "effect"
// Using log levels with Effect logging
const program = Effect.gen(function*() {
yield* Effect.logFatal("System failure")
yield* Effect.logError("Database error")
yield* Effect.logWarning("High memory usage")
yield* Effect.logInfo("User logged in")
yield* Effect.logDebug("Processing request")
yield* Effect.logTrace("Variable state")
})
// Type-safe log level variables
const errorLevel = "Error" // LogLevel
const debugLevel = "Debug" // LogLevel
LogLevel): import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<boolean> =>
import corecore.const withFiber: <
A,
E = never,
R = never
>(
evaluate: (
fiber: FiberImpl<unknown, unknown>
) => Effect.Effect<A, E, R>
) => Effect.Effect<A, E, R>
fiber: effect.FiberImpl<unknown, unknown>(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: core.Primitive) => void;
runLoop: (effect: core.Primitive) => typeof core.Yield | Exit<unknown, unknown>;
getCont: <S extends core.contA | core.contE>(symbol: S) => (core.Primitive & Record<S, (value: any, fiber: effect.FiberImpl) => core.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 succeed: <A>(
value: A
) => Effect.Effect<A>
const isGreaterThan: {
(that: LogLevel): (self: LogLevel) => boolean
(self: LogLevel, that: LogLevel): boolean
}
fiber: effect.FiberImpl<unknown, unknown>(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: core.Primitive) => void;
runLoop: (effect: core.Primitive) => typeof core.Yield | Exit<unknown, unknown>;
getCont: <S extends core.contA | core.contE>(symbol: S) => (core.Primitive & Record<S, (value: any, fiber: effect.FiberImpl) => core.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;
}
FiberImpl<X>(ref: Context.Reference<X>): XgetRef(import ReferencesReferences.const MinimumLogLevel: Context.Reference<LogLevel>const MinimumLogLevel: {
defaultValue: () => Shape;
of: (this: void, self: LogLevel) => LogLevel;
context: (self: LogLevel) => Context<never>;
use: (f: (service: LogLevel) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
useSync: (f: (service: LogLevel) => A) => Effect.Effect<A, never, never>;
Identifier: Identifier;
Service: Shape;
key: string;
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 for setting the minimum log level threshold. Log entries below this
level will be filtered out completely.
When to use
Use to filter out log entries below a severity threshold.
Example (Setting the minimum log level)
import { Console, Effect, References } from "effect"
const configureMinimumLogging = Effect.gen(function*() {
// Get current minimum level (default is "Info")
const current = yield* References.MinimumLogLevel
console.log(current) // "Info"
// Set minimum level to Warn - Debug and Info will be filtered
yield* Effect.provideService(
Effect.gen(function*() {
const minLevel = yield* References.MinimumLogLevel
console.log(minLevel) // "Warn"
// These won't be processed at all
yield* Console.debug("Debug message") // Filtered out
yield* Console.info("Info message") // Filtered out
// These will be processed
yield* Console.warn("Warning message") // Shown
yield* Console.error("Error message") // Shown
}),
References.MinimumLogLevel,
"Warn"
)
// Reset to default Info level
yield* Effect.provideService(
Effect.gen(function*() {
const minLevel = yield* References.MinimumLogLevel
console.log(minLevel) // "Info"
// Now info messages will be processed
yield* Console.info("Info message") // Shown
}),
References.MinimumLogLevel,
"Info"
)
})
MinimumLogLevel), self: LogLevelself)))