veffect
Version:
powerful TypeScript validation library built on the robust foundation of Effect combining exceptional type safety, high performance, and developer experience. Taking inspiration from Effect's functional principles, VEffect delivers a balanced approach tha
319 lines • 10.4 kB
TypeScript
/**
* @since 2.0.0
*/
import type * as Cause from "./Cause.js";
import type { DurationInput } from "./Duration.js";
import type { Effect } from "./Effect.js";
import type * as FiberId from "./FiberId.js";
import type * as FiberRefs from "./FiberRefs.js";
import type { LazyArg } from "./Function.js";
import type * as HashMap from "./HashMap.js";
import type * as Layer from "./Layer.js";
import type * as List from "./List.js";
import type * as LogLevel from "./LogLevel.js";
import type * as LogSpan from "./LogSpan.js";
import type * as Option from "./Option.js";
import type { Pipeable } from "./Pipeable.js";
import type { Scope } from "./Scope.js";
import type * as Types from "./Types.js";
/**
* @since 2.0.0
* @category symbols
*/
export declare const LoggerTypeId: unique symbol;
/**
* @since 2.0.0
* @category symbols
*/
export type LoggerTypeId = typeof LoggerTypeId;
/**
* @since 2.0.0
* @category models
*/
export interface Logger<in Message, out Output> extends Logger.Variance<Message, Output>, Pipeable {
log(options: Logger.Options<Message>): Output;
}
/**
* @since 2.0.0
*/
export declare namespace Logger {
/**
* @since 2.0.0
* @category models
*/
interface Variance<in Message, out Output> {
readonly [LoggerTypeId]: {
readonly _Message: Types.Contravariant<Message>;
readonly _Output: Types.Covariant<Output>;
};
}
/**
* @since 2.0.0
* @category models
*/
interface Options<out Message> {
readonly fiberId: FiberId.FiberId;
readonly logLevel: LogLevel.LogLevel;
readonly message: Message;
readonly cause: Cause.Cause<unknown>;
readonly context: FiberRefs.FiberRefs;
readonly spans: List.List<LogSpan.LogSpan>;
readonly annotations: HashMap.HashMap<string, unknown>;
readonly date: Date;
}
}
/**
* @category constructors
* @since 2.0.0
*/
export declare const make: <Message, Output>(log: (options: Logger.Options<Message>) => Output) => Logger<Message, Output>;
/**
* @since 2.0.0
* @category context
*/
export declare const add: <B>(logger: Logger<unknown, B>) => Layer.Layer<never>;
/**
* @since 2.0.0
* @category context
*/
export declare const addEffect: <A, E, R>(effect: Effect<Logger<unknown, A>, E, R>) => Layer.Layer<never, E, R>;
/**
* @since 2.0.0
* @category context
*/
export declare const addScoped: <A, E, R>(effect: Effect<Logger<unknown, A>, E, R>) => Layer.Layer<never, E, Exclude<R, Scope>>;
/**
* @since 2.0.0
* @category mapping
*/
export declare const mapInput: {
<Message, Message2>(f: (message: Message2) => Message): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>;
<Output, Message, Message2>(self: Logger<Message, Output>, f: (message: Message2) => Message): Logger<Message2, Output>;
};
/**
* @since 2.0.0
* @category mapping
*/
export declare const mapInputOptions: {
<Message, Message2>(f: (options: Logger.Options<Message2>) => Logger.Options<Message>): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>;
<Output, Message, Message2>(self: Logger<Message, Output>, f: (options: Logger.Options<Message2>) => Logger.Options<Message>): Logger<Message2, Output>;
};
/**
* Returns a version of this logger that only logs messages when the log level
* satisfies the specified predicate.
*
* @since 2.0.0
* @category filtering
*/
export declare const filterLogLevel: {
(f: (logLevel: LogLevel.LogLevel) => boolean): <Message, Output>(self: Logger<Message, Output>) => Logger<Message, Option.Option<Output>>;
<Message, Output>(self: Logger<Message, Output>, f: (logLevel: LogLevel.LogLevel) => boolean): Logger<Message, Option.Option<Output>>;
};
/**
* @since 2.0.0
* @category mapping
*/
export declare const map: {
<Output, Output2>(f: (output: Output) => Output2): <Message>(self: Logger<Message, Output>) => Logger<Message, Output2>;
<Message, Output, Output2>(self: Logger<Message, Output>, f: (output: Output) => Output2): Logger<Message, Output2>;
};
/**
* @since 2.0.0
* @category mapping
* @example
* import { Console, Effect, Logger } from "effect";
*
* const LoggerLive = Logger.replaceScoped(
* Logger.defaultLogger,
* Logger.logfmtLogger.pipe(
* Logger.batched("500 millis", (messages) =>
* Console.log("BATCH", messages.join("\n"))
* )
* )
* );
*
* Effect.gen(function* (_) {
* yield* _(Effect.log("one"));
* yield* _(Effect.log("two"));
* yield* _(Effect.log("three"));
* }).pipe(Effect.provide(LoggerLive), Effect.runFork);
*/
export declare const batched: {
<Output, R>(window: DurationInput, f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>): <Message>(self: Logger<Message, Output>) => Effect<Logger<Message, void>, never, R | Scope>;
<Message, Output, R>(self: Logger<Message, Output>, window: DurationInput, f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>): Effect<Logger<Message, void>, never, Scope | R>;
};
/**
* @since 2.0.0
* @category console
*/
export declare const withConsoleLog: <M, O>(self: Logger<M, O>) => Logger<M, void>;
/**
* @since 2.0.0
* @category console
*/
export declare const withConsoleError: <M, O>(self: Logger<M, O>) => Logger<M, void>;
/**
* A logger that does nothing in response to logging events.
*
* @since 2.0.0
* @category constructors
*/
export declare const none: Logger<unknown, void>;
/**
* @since 2.0.0
* @category context
*/
export declare const remove: <A>(logger: Logger<unknown, A>) => Layer.Layer<never>;
/**
* @since 2.0.0
* @category context
*/
export declare const replace: {
<B>(that: Logger<unknown, B>): <A>(self: Logger<unknown, A>) => Layer.Layer<never>;
<A, B>(self: Logger<unknown, A>, that: Logger<unknown, B>): Layer.Layer<never>;
};
/**
* @since 2.0.0
* @category context
*/
export declare const replaceEffect: {
<B, E, R>(that: Effect<Logger<unknown, B>, E, R>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, R>;
<A, B, E, R>(self: Logger<unknown, A>, that: Effect<Logger<unknown, B>, E, R>): Layer.Layer<never, E, R>;
};
/**
* @since 2.0.0
* @category context
*/
export declare const replaceScoped: {
<B, E, R>(that: Effect<Logger<unknown, B>, E, R>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>;
<A, B, E, R>(self: Logger<unknown, A>, that: Effect<Logger<unknown, B>, E, R>): Layer.Layer<never, E, Exclude<R, Scope>>;
};
/**
* @since 2.0.0
* @category constructors
*/
export declare const simple: <A, B>(log: (a: A) => B) => Logger<A, B>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const succeed: <A>(value: A) => Logger<unknown, A>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const sync: <A>(evaluate: LazyArg<A>) => Logger<unknown, A>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const test: {
<Message>(input: Message): <Output>(self: Logger<Message, Output>) => Output;
<Message, Output>(self: Logger<Message, Output>, input: Message): Output;
};
/**
* @since 2.0.0
* @category context
*/
export declare const withMinimumLogLevel: {
(level: LogLevel.LogLevel): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
<A, E, R>(self: Effect<A, E, R>, level: LogLevel.LogLevel): Effect<A, E, R>;
};
/**
* @since 2.0.0
* @category tracing
*/
export declare const withSpanAnnotations: <Message, Output>(self: Logger<Message, Output>) => Logger<Message, Output>;
/**
* Combines this logger with the specified logger to produce a new logger that
* logs to both this logger and that logger.
*
* @since 2.0.0
* @category zipping
*/
export declare const zip: {
<Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, [Output, Output2]>;
<Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, [Output, Output2]>;
};
/**
* @since 2.0.0
* @category zipping
*/
export declare const zipLeft: {
<Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output>;
<Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, Output>;
};
/**
* @since 2.0.0
* @category zipping
*/
export declare const zipRight: {
<Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output2>;
<Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, Output2>;
};
/**
* @since 2.0.0
* @category constructors
*/
export declare const defaultLogger: Logger<unknown, void>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const jsonLogger: Logger<unknown, string>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const logfmtLogger: Logger<unknown, string>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const stringLogger: Logger<unknown, string>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const structuredLogger: Logger<unknown, {
readonly logLevel: string;
readonly fiberId: string;
readonly timestamp: string;
readonly message: unknown;
readonly cause: string | undefined;
readonly annotations: Record<string, unknown>;
readonly spans: Record<string, number>;
}>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const tracerLogger: Logger<unknown, void>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const json: Layer.Layer<never>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const logFmt: Layer.Layer<never>;
/**
* @since 2.0.0
* @category constructors
*/
export declare const structured: Layer.Layer<never>;
/**
* @since 2.0.0
* @category context
*/
export declare const minimumLogLevel: (level: LogLevel.LogLevel) => Layer.Layer<never>;
/**
* Returns `true` if the specified value is a `Logger`, otherwise returns `false`.
*
* @since 1.0.0
* @category guards
*/
export declare const isLogger: (u: unknown) => u is Logger<unknown, unknown>;
//# sourceMappingURL=Logger.d.ts.map