effect 2.0.0-next.44 → 2.0.0-next.46

package/src/LogLevel.ts

@@ -0,0 +1,266 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import { dual, pipe } from "./Function"
+import * as core from "./internal/core"
+import * as number from "./Number"
+import * as order from "./Order"
+import type { Pipeable } from "./Pipeable"
+
+/**
+ * A `LogLevel` represents the log level associated with an individual logging
+ * operation. Log levels are used both to describe the granularity (or
+ * importance) of individual log statements, as well as to enable tuning
+ * verbosity of log output.
+ *
+ * @since 2.0.0
+ * @category model
+ * @property ordinal - The priority of the log message. Larger values indicate higher priority.
+ * @property label - A label associated with the log level.
+ * @property syslog -The syslog severity level of the log level.
+ */
+export type LogLevel = All | Fatal | Error | Warning | Info | Debug | Trace | None
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export type Literal = LogLevel["_tag"]
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface All extends Pipeable {
+  readonly _tag: "All"
+  readonly label: "ALL"
+  readonly syslog: 0
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface Fatal extends Pipeable {
+  readonly _tag: "Fatal"
+  readonly label: "FATAL"
+  readonly syslog: 2
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface Error extends Pipeable {
+  readonly _tag: "Error"
+  readonly label: "ERROR"
+  readonly syslog: 3
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface Warning extends Pipeable {
+  readonly _tag: "Warning"
+  readonly label: "WARN"
+  readonly syslog: 4
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface Info extends Pipeable {
+  readonly _tag: "Info"
+  readonly label: "INFO"
+  readonly syslog: 6
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface Debug extends Pipeable {
+  readonly _tag: "Debug"
+  readonly label: "DEBUG"
+  readonly syslog: 7
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface Trace extends Pipeable {
+  readonly _tag: "Trace"
+  readonly label: "TRACE"
+  readonly syslog: 7
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface None extends Pipeable {
+  readonly _tag: "None"
+  readonly label: "OFF"
+  readonly syslog: 7
+  readonly ordinal: number
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const All: LogLevel = core.logLevelAll
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Fatal: LogLevel = core.logLevelFatal
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Error: LogLevel = core.logLevelError
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Warning: LogLevel = core.logLevelWarning
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Info: LogLevel = core.logLevelInfo
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Debug: LogLevel = core.logLevelDebug
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Trace: LogLevel = core.logLevelTrace
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const None: LogLevel = core.logLevelNone
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const allLevels = core.allLogLevels
+
+/**
+ * Locally applies the specified `LogLevel` to an `Effect` workflow, reverting
+ * to the previous `LogLevel` after the `Effect` workflow completes.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const locally: {
+  (self: LogLevel): <R, E, B>(use: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B>
+  <R, E, B>(use: Effect.Effect<R, E, B>, self: LogLevel): Effect.Effect<R, E, B>
+} = dual<
+  (self: LogLevel) => <R, E, B>(use: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B>,
+  <R, E, B>(use: Effect.Effect<R, E, B>, self: LogLevel) => Effect.Effect<R, E, B>
+>(2, (use, self) => core.fiberRefLocally(use, core.currentLogLevel, self))
+
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+export const Order: order.Order<LogLevel> = pipe(
+  number.Order,
+  order.mapInput((level: LogLevel) => level.ordinal)
+)
+
+/**
+ * @since 2.0.0
+ * @category ordering
+ */
+export const lessThan: {
+  (that: LogLevel): (self: LogLevel) => boolean
+  (self: LogLevel, that: LogLevel): boolean
+} = order.lessThan(Order)
+
+/**
+ * @since 2.0.0
+ * @category ordering
+ */
+export const lessThanEqual: {
+  (that: LogLevel): (self: LogLevel) => boolean
+  (self: LogLevel, that: LogLevel): boolean
+} = order.lessThanOrEqualTo(Order)
+
+/**
+ * @since 2.0.0
+ * @category ordering
+ */
+export const greaterThan: {
+  (that: LogLevel): (self: LogLevel) => boolean
+  (self: LogLevel, that: LogLevel): boolean
+} = order.greaterThan(Order)
+
+/**
+ * @since 2.0.0
+ * @category ordering
+ */
+export const greaterThanEqual: {
+  (that: LogLevel): (self: LogLevel) => boolean
+  (self: LogLevel, that: LogLevel): boolean
+} = order.greaterThanOrEqualTo(Order)
+
+/**
+ * @since 2.0.0
+ * @category conversions
+ */
+export const fromLiteral = (
+  _: Literal
+): LogLevel => {
+  switch (_) {
+    case "All": {
+      return All
+    }
+    case "Debug": {
+      return Debug
+    }
+    case "Error": {
+      return Error
+    }
+    case "Fatal": {
+      return Fatal
+    }
+    case "Info": {
+      return Info
+    }
+    case "Trace": {
+      return Trace
+    }
+    case "None": {
+      return None
+    }
+    case "Warning": {
+      return Warning
+    }
+  }
+}

package/src/LogSpan.ts

@@ -0,0 +1,25 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/logSpan"
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface LogSpan {
+  readonly label: string
+  readonly startTime: number
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (label: string, startTime: number) => LogSpan = internal.make
+
+/**
+ * @since 2.0.0
+ * @category destructors
+ */
+export const render: (now: number) => (self: LogSpan) => string = internal.render

package/src/Logger.ts

@@ -0,0 +1,321 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Cause from "./Cause"
+import type { Effect } from "./Effect"
+import type * as FiberId from "./FiberId"
+import type * as FiberRefs from "./FiberRefs"
+import type { LazyArg } from "./Function"
+import type * as HashMap from "./HashMap"
+import * as fiberRuntime from "./internal/fiberRuntime"
+import * as circular from "./internal/layer/circular"
+import * as internal from "./internal/logger"
+import * as internalCircular from "./internal/logger-circular"
+import type * as Layer from "./Layer"
+import type * as List from "./List"
+import type * as LogLevel from "./LogLevel"
+import type * as LogSpan from "./LogSpan"
+import type * as Option from "./Option"
+import type { Pipeable } from "./Pipeable"
+import type { Scope } from "./Scope"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const LoggerTypeId: unique symbol = internal.LoggerTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type LoggerTypeId = typeof LoggerTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Logger<Message, Output> extends Logger.Variance<Message, Output>, Pipeable {
+  readonly log: (
+    options: {
+      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, AnnotationValue>
+      readonly date: Date
+    }
+  ) => Output
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Logger {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<Message, Output> {
+    readonly [LoggerTypeId]: {
+      readonly _Message: (_: Message) => void
+      readonly _Output: (_: never) => Output
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type AnnotationValue = string | number | boolean
+
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export const make: <Message, Output>(
+  log: (
+    options: {
+      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, AnnotationValue>
+      readonly date: Date
+    }
+  ) => Output
+) => Logger<Message, Output> = internal.makeLogger
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const add: <B>(logger: Logger<unknown, B>) => Layer.Layer<never, never, never> = circular.addLogger
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const addEffect: <R, E, A>(effect: Effect<R, E, Logger<unknown, A>>) => Layer.Layer<R, E, never> =
+  circular.addLoggerEffect
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const addScoped: <R, E, A>(
+  effect: Effect<R, E, Logger<unknown, A>>
+) => Layer.Layer<Exclude<R, Scope>, E, never> = circular.addLoggerScoped
+
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+export 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>
+} = internal.mapInput
+
+/**
+ * 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 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>>
+} = internal.filterLogLevel
+
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+export 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>
+} = internal.map
+
+/**
+ * A logger that does nothing in response to logging events.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const none: Logger<unknown, void> = internal.none
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const remove: <A>(logger: Logger<unknown, A>) => Layer.Layer<never, never, never> = circular.removeLogger
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const replace: {
+  <B>(that: Logger<unknown, B>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, never, never>
+  <A, B>(self: Logger<unknown, A>, that: Logger<unknown, B>): Layer.Layer<never, never, never>
+} = circular.replaceLogger
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const replaceEffect: {
+  <R, E, B>(that: Effect<R, E, Logger<unknown, B>>): <A>(self: Logger<unknown, A>) => Layer.Layer<R, E, never>
+  <A, R, E, B>(self: Logger<unknown, A>, that: Effect<R, E, Logger<unknown, B>>): Layer.Layer<R, E, never>
+} = circular.replaceLoggerEffect
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const replaceScoped: {
+  <R, E, B>(
+    that: Effect<R, E, Logger<unknown, B>>
+  ): <A>(self: Logger<unknown, A>) => Layer.Layer<Exclude<R, Scope>, E, never>
+  <A, R, E, B>(
+    self: Logger<unknown, A>,
+    that: Effect<R, E, Logger<unknown, B>>
+  ): Layer.Layer<Exclude<R, Scope>, E, never>
+} = circular.replaceLoggerScoped
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const simple: <A, B>(log: (a: A) => B) => Logger<A, B> = internal.simple
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const succeed: <A>(value: A) => Logger<unknown, A> = internal.succeed
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sync: <A>(evaluate: LazyArg<A>) => Logger<unknown, A> = internal.sync
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const test: {
+  <Message>(input: Message): <Output>(self: Logger<Message, Output>) => Output
+  <Message, Output>(self: Logger<Message, Output>, input: Message): Output
+} = internalCircular.test
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const withMinimumLogLevel: {
+  (level: LogLevel.LogLevel): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A>(self: Effect<R, E, A>, level: LogLevel.LogLevel): Effect<R, E, A>
+} = circular.withMinimumLogLevel
+
+/**
+ * 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 const zip: {
+  <Message2, Output2>(
+    that: Logger<Message2, Output2>
+  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, readonly [Output, Output2]>
+  <Message, Output, Message2, Output2>(
+    self: Logger<Message, Output>,
+    that: Logger<Message2, Output2>
+  ): Logger<Message & Message2, readonly [Output, Output2]>
+} = internal.zip
+
+/**
+ * @since 2.0.0
+ * @category zipping
+ */
+export 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>
+} = internal.zipLeft
+
+/**
+ * @since 2.0.0
+ * @category zipping
+ */
+export 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>
+} = internal.zipRight
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const defaultLogger: Logger<unknown, void> = fiberRuntime.defaultLogger
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const logfmtLogger: Logger<unknown, string> = internal.logfmtLogger
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const stringLogger: Logger<unknown, string> = internal.stringLogger
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const tracerLogger: Logger<unknown, void> = fiberRuntime.tracerLogger
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const logFmt: Layer.Layer<never, never, never> = replace(fiberRuntime.defaultLogger, fiberRuntime.logFmtLogger)
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const minimumLogLevel: (level: LogLevel.LogLevel) => Layer.Layer<never, never, never> = circular.minimumLogLevel