effect 3.4.9 → 3.5.1

package/src/internal/core.ts

@@ -2174,23 +2174,19 @@ export const causeSquashWith = dual<
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const YieldableError: new(message?: string) => Cause.YieldableError = (function() {
+export const YieldableError: new(message?: string, options?: ErrorOptions) => Cause.YieldableError = (function() {
   class YieldableError extends globalThis.Error {
     commit() {
       return fail(this)
     }
-    toString() {
-      return this.message ? `${this.name}: ${this.message}` : this.name
-    }
     toJSON() {
       return { ...this }
     }
-    [NodeInspectSymbol](): string {
-      const stack = this.stack
-      if (stack) {
-        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`
+    [NodeInspectSymbol]() {
+      if (this.toString !== globalThis.Error.prototype.toString) {
+        return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString()
       }
-      return this.toString()
+      return this
     }
   }
   Object.assign(YieldableError.prototype, StructuralCommitPrototype)
@@ -2274,6 +2270,20 @@ export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubC
   [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
 }, "InvalidPubSubCapacityException")
 
+/** @internal */
+export const ExceededCapacityExceptionTypeId: Cause.ExceededCapacityExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/ExceededCapacityException"
+) as Cause.ExceededCapacityExceptionTypeId
+
+/** @internal */
+export const ExceededCapacityException = makeException<Cause.ExceededCapacityException>({
+  [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId
+}, "ExceededCapacityException")
+
+/** @internal */
+export const isExceededCapacityException = (u: unknown): u is Cause.ExceededCapacityException =>
+  hasProperty(u, ExceededCapacityExceptionTypeId)
+
 /** @internal */
 export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
   hasProperty(u, InvalidPubSubCapacityExceptionTypeId)

package/src/internal/defaultServices.ts

@@ -22,7 +22,7 @@ export const liveServices: Context.Context<DefaultServices.DefaultServices> = pi
   Context.empty(),
   Context.add(clock.clockTag, clock.make()),
   Context.add(console_.consoleTag, console_.defaultConsole),
-  Context.add(random.randomTag, random.make((Math.random() * 4294967296) >>> 0)),
+  Context.add(random.randomTag, random.make(Math.random())),
   Context.add(configProvider.configProviderTag, configProvider.fromEnv()),
   Context.add(tracer.tracerTag, tracer.nativeTracer)
 )

package/src/internal/fiberRuntime.ts

@@ -1421,6 +1421,12 @@ export const logFmtLogger: Logger<unknown, void> = globalValue(
   () => loggerWithConsoleLog(internalLogger.logfmtLogger)
 )
 
+/** @internal */
+export const prettyLogger: Logger<unknown, void> = globalValue(
+  Symbol.for("effect/Logger/prettyLogger"),
+  () => internalLogger.prettyLogger()
+)
+
 /** @internal */
 export const structuredLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/structuredLogger"),

package/src/internal/logger.ts

@@ -1,3 +1,6 @@
+import * as Arr from "../Array.js"
+import * as Context from "../Context.js"
+import * as FiberRefs from "../FiberRefs.js"
 import type { LazyArg } from "../Function.js"
 import { constVoid, dual, pipe } from "../Function.js"
 import * as HashMap from "../HashMap.js"
@@ -9,6 +12,8 @@ import * as LogSpan from "../LogSpan.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Cause from "./cause.js"
+import * as defaultServices from "./defaultServices.js"
+import { consoleTag } from "./defaultServices/console.js"
 import * as _fiberId from "./fiberId.js"
 
 /** @internal */
@@ -157,7 +162,7 @@ export const zipRight = dual<
 >(2, (self, that) => map(zip(self, that), (tuple) => tuple[1]))
 
 /** @internal */
-export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown, string>(
+export const stringLogger: Logger.Logger<unknown, string> = makeLogger(
   ({ annotations, cause, date, fiberId, logLevel, message, spans }) => {
     const nowMillis = date.getTime()
 
@@ -169,16 +174,9 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
 
     let output = outputArray.join(" ")
 
-    if (Array.isArray(message)) {
-      for (let i = 0; i < message.length; i++) {
-        const stringMessage = Inspectable.toStringUnknown(message[i])
-        if (stringMessage.length > 0) {
-          output = output + " message="
-          output = appendQuoted(stringMessage, output)
-        }
-      }
-    } else {
-      const stringMessage = Inspectable.toStringUnknown(message)
+    const messageArr = Arr.ensure(message)
+    for (let i = 0; i < messageArr.length; i++) {
+      const stringMessage = Inspectable.toStringUnknown(messageArr[i])
       if (stringMessage.length > 0) {
         output = output + " message="
         output = appendQuoted(stringMessage, output)
@@ -187,7 +185,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
 
     if (cause != null && cause._tag !== "Empty") {
       output = output + " cause="
-      output = appendQuoted(Cause.pretty(cause), output)
+      output = appendQuoted(Cause.pretty(cause, { renderErrorCause: true }), output)
     }
 
     if (List.isCons(spans)) {
@@ -204,7 +202,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
       }
     }
 
-    if (pipe(annotations, HashMap.size) > 0) {
+    if (HashMap.size(annotations) > 0) {
       output = output + " "
 
       let first = true
@@ -246,16 +244,9 @@ export const logfmtLogger = makeLogger<unknown, string>(
 
     let output = outputArray.join(" ")
 
-    if (Array.isArray(message)) {
-      for (let i = 0; i < message.length; i++) {
-        const stringMessage = Inspectable.toStringUnknown(message[i], 0)
-        if (stringMessage.length > 0) {
-          output = output + " message="
-          output = appendQuotedLogfmt(stringMessage, output)
-        }
-      }
-    } else {
-      const stringMessage = Inspectable.toStringUnknown(message, 0)
+    const messageArr = Arr.ensure(message)
+    for (let i = 0; i < messageArr.length; i++) {
+      const stringMessage = Inspectable.toStringUnknown(messageArr[i], 0)
       if (stringMessage.length > 0) {
         output = output + " message="
         output = appendQuotedLogfmt(stringMessage, output)
@@ -264,7 +255,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
 
     if (cause != null && cause._tag !== "Empty") {
       output = output + " cause="
-      output = appendQuotedLogfmt(Cause.pretty(cause), output)
+      output = appendQuotedLogfmt(Cause.pretty(cause, { renderErrorCause: true }), output)
     }
 
     if (List.isCons(spans)) {
@@ -281,7 +272,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
       }
     }
 
-    if (pipe(annotations, HashMap.size) > 0) {
+    if (HashMap.size(annotations) > 0) {
       output = output + " "
 
       let first = true
@@ -328,11 +319,12 @@ export const structuredLogger = makeLogger<unknown, {
       }
     }
 
+    const messageArr = Arr.ensure(message)
     return {
-      message: structuredMessage(message),
+      message: messageArr.length === 1 ? structuredMessage(messageArr[0]) : messageArr.map(structuredMessage),
       logLevel: logLevel.label,
       timestamp: date.toISOString(),
-      cause: Cause.isEmpty(cause) ? undefined : Cause.pretty(cause),
+      cause: Cause.isEmpty(cause) ? undefined : Cause.pretty(cause, { renderErrorCause: true }),
       annotations: annotationsObj,
       spans: spansObj,
       fiberId: _fiberId.threadName(fiberId)
@@ -376,3 +368,119 @@ const renderLogSpanLogfmt = (now: number) => (self: LogSpan.LogSpan): string =>
 export const isLogger = (u: unknown): u is Logger.Logger<unknown, unknown> => {
   return typeof u === "object" && u != null && LoggerTypeId in u
 }
+
+const withColor = (text: string, ...colors: ReadonlyArray<string>) => {
+  let out = ""
+  for (let i = 0; i < colors.length; i++) {
+    out += `\x1b[${colors[i]}m`
+  }
+  return out + text + "\x1b[0m"
+}
+const withColorNoop = (text: string, ..._colors: ReadonlyArray<string>) => text
+const colors = {
+  bold: "1",
+  red: "31",
+  green: "32",
+  yellow: "33",
+  blue: "34",
+  cyan: "36",
+  white: "37",
+  gray: "90",
+  black: "30",
+  bgBrightRed: "101"
+} as const
+
+const logLevelColors: Record<LogLevel.LogLevel["_tag"], ReadonlyArray<string>> = {
+  None: [],
+  All: [],
+  Trace: [colors.gray],
+  Debug: [colors.blue],
+  Info: [colors.green],
+  Warning: [colors.yellow],
+  Error: [colors.red],
+  Fatal: [colors.bgBrightRed, colors.black]
+}
+
+const defaultDateFormat = (date: Date): string =>
+  `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}:${
+    date.getSeconds().toString().padStart(2, "0")
+  }.${date.getMilliseconds().toString().padStart(3, "0")}`
+
+const processStdoutIsTTY = typeof process === "object" && "stdout" in process && process.stdout.isTTY === true
+const processIsBun = typeof process === "object" && "isBun" in process && process.isBun === true
+const hasWindow = typeof window === "object"
+
+/** @internal */
+export const prettyLogger = (options?: {
+  readonly colors?: "auto" | boolean | undefined
+  readonly stderr?: boolean | undefined
+  readonly formatDate?: ((date: Date) => string) | undefined
+  readonly mode?: "browser" | "tty" | "auto" | undefined
+}) => {
+  const mode_ = options?.mode ?? "auto"
+  const mode = mode_ === "auto" ? (hasWindow ? "browser" : "tty") : mode_
+  const isBrowser = mode === "browser"
+  const showColors = typeof options?.colors === "boolean" ? options.colors : processStdoutIsTTY || isBrowser
+  const color = showColors ? withColor : withColorNoop
+  const formatDate = options?.formatDate ?? defaultDateFormat
+
+  return makeLogger<unknown, void>(
+    ({ annotations, cause, context, date, fiberId, logLevel, message: message_, spans }) => {
+      const services = FiberRefs.getOrDefault(context, defaultServices.currentServices)
+      const console = Context.get(services, consoleTag).unsafe
+      const log = options?.stderr === true ? console.error : console.log
+
+      const message = Arr.ensure(message_)
+
+      let firstLine = color(`[${formatDate(date)}]`, colors.white)
+        + ` ${color(logLevel.label, ...logLevelColors[logLevel._tag])}`
+        + ` (${_fiberId.threadName(fiberId)})`
+
+      if (List.isCons(spans)) {
+        const now = date.getTime()
+        const render = renderLogSpanLogfmt(now)
+        for (const span of spans) {
+          firstLine += " " + render(span)
+        }
+      }
+
+      firstLine += ":"
+      let messageIndex = 0
+      if (message.length > 0) {
+        const firstMaybeString = structuredMessage(message[0])
+        if (typeof firstMaybeString === "string") {
+          firstLine += " " + color(firstMaybeString, colors.bold, colors.cyan)
+          messageIndex++
+        }
+      }
+
+      if (isBrowser) {
+        console.groupCollapsed(firstLine)
+      } else {
+        log(firstLine)
+        if (!processIsBun) console.group()
+      }
+      if (!Cause.isEmpty(cause)) {
+        if (isBrowser) {
+          console.error(Cause.pretty(cause, { renderErrorCause: true }))
+        } else {
+          log(Cause.pretty(cause, { renderErrorCause: true }))
+        }
+      }
+
+      if (messageIndex < message.length) {
+        for (; messageIndex < message.length; messageIndex++) {
+          log(message[messageIndex])
+        }
+      }
+
+      if (HashMap.size(annotations) > 0) {
+        for (const [key, value] of annotations) {
+          log(color(`${key}:`, colors.bold, colors.white), value)
+        }
+      }
+
+      if (!processIsBun) console.groupEnd()
+    }
+  )
+}