@livestore/utils 0.3.0-dev.16 → 0.3.0-dev.18

package/src/effect/BucketQueue.ts

@@ -1,4 +1,6 @@
-import { Array, STM, TRef } from 'effect'
+import { Array, Effect, STM, TRef } from 'effect'
+
+import { ReadonlyArray } from './index.js'
 
 export type BucketQueue<A> = TRef.TRef<A[]>
 
@@ -7,22 +9,43 @@ export const make = <A>(): STM.STM<BucketQueue<A>> => TRef.make<A[]>([])
 export const offerAll = <A>(self: BucketQueue<A>, elements: ReadonlyArray<A>) =>
   TRef.update(self, (bucket) => Array.appendAll(bucket, elements))
 
+export const replace = <A>(self: BucketQueue<A>, elements: ReadonlyArray<A>) => TRef.set(self, elements as A[])
+
 export const clear = <A>(self: BucketQueue<A>) => TRef.set(self, [])
 
 export const takeBetween = <A>(
-  self: BucketQueue<A>,
+  bucket: BucketQueue<A>,
   min: number,
   max: number,
 ): STM.STM<ReadonlyArray<A>, never, never> =>
   STM.gen(function* () {
-    const bucket = yield* TRef.get(self)
-    if (bucket.length < min) {
+    const bucketValue = yield* TRef.get(bucket)
+    if (bucketValue.length < min) {
       return yield* STM.retry
     } else {
-      const elements = bucket.splice(0, Math.min(max, bucket.length))
-      yield* TRef.set(self, bucket)
+      const elements = bucketValue.splice(0, Math.min(max, bucketValue.length))
+      yield* TRef.set(bucket, bucketValue)
       return elements
     }
   })
 
-export const takeAll = <A>(self: BucketQueue<A>) => TRef.get(self)
+export const peekAll = <A>(bucket: BucketQueue<A>) => TRef.get(bucket)
+
+/** Returns the elements up to the first element that matches the predicate, the rest is left in the queue
+ *
+ * @example
+ * ```ts
+ * const [elements, rest] = yield* BucketQueue.takeSplitWhere(bucket, (a) => a > 3)
+ * assert.deepStrictEqual(elements, [1, 2, 3])
+ * assert.deepStrictEqual(rest, [4, 5, 6])
+ * ```
+ */
+export const takeSplitWhere = <A>(bucket: BucketQueue<A>, predicate: (a: A) => boolean) =>
+  STM.gen(function* () {
+    const bucketValue = yield* TRef.get(bucket)
+    const [elements, rest] = ReadonlyArray.splitWhere(bucketValue, predicate)
+    yield* TRef.set(bucket, rest)
+    return elements
+  })
+
+export const size = <A>(bucket: BucketQueue<A>) => TRef.get(bucket).pipe(Effect.map((_) => _.length))

package/src/effect/Effect.ts

@@ -125,11 +125,11 @@ export const logWarnIfTakesLongerThan =
     Effect.gen(function* () {
       const runtime = yield* Effect.runtime<never>()
 
-      let timedOut = false
+      let tookLongerThanTimer = false
 
       const timeoutFiber = Effect.sleep(duration).pipe(
         Effect.tap(() => {
-          timedOut = true
+          tookLongerThanTimer = true
           // TODO include span info
           return Effect.logWarning(`${label}: Took longer than ${duration}ms`)
         }),
@@ -138,9 +138,22 @@ export const logWarnIfTakesLongerThan =
       )
 
       const start = Date.now()
-      const res = yield* eff.pipe(Effect.exit)
+      const res = yield* eff.pipe(
+        Effect.exit,
+        Effect.onInterrupt(
+          Effect.fn(function* () {
+            const end = Date.now()
+
+            yield* Fiber.interrupt(timeoutFiber)
+
+            if (tookLongerThanTimer) {
+              yield* Effect.logWarning(`${label}: Interrupted after ${end - start}ms`)
+            }
+          }),
+        ),
+      )
 
-      if (timedOut) {
+      if (tookLongerThanTimer) {
         const end = Date.now()
         yield* Effect.logWarning(`${label}: Actual duration: ${end - start}ms`)
       }

package/src/effect/Logger.ts

@@ -1,4 +1,4 @@
-import { Logger } from 'effect'
+import { Cause, HashMap, Logger, LogLevel } from 'effect'
 
 export * from 'effect/Logger'
 
@@ -14,4 +14,26 @@ export const prettyWithThread = (threadName: string) =>
     Logger.prettyLogger({
       formatDate: (date) => `${defaultDateFormat(date)} ${threadName}`,
     }),
+    // consoleLogger(threadName),
   )
+
+export const consoleLogger = (threadName: string) =>
+  Logger.make(({ message, annotations, date, logLevel, cause }) => {
+    const consoleFn =
+      logLevel === LogLevel.Debug
+        ? console.debug
+        : logLevel === LogLevel.Info
+          ? console.info
+          : logLevel === LogLevel.Warning
+            ? console.warn
+            : console.error
+
+    const annotationsObj = Object.fromEntries(HashMap.entries(annotations))
+
+    const messages = Array.isArray(message) ? message : [message]
+    if (Cause.isEmpty(cause) === false) {
+      messages.push(Cause.pretty(cause, { renderErrorCause: true }))
+    }
+
+    consoleFn(`[${defaultDateFormat(date)} ${threadName}]`, ...messages, annotationsObj)
+  })

package/src/effect/WebChannel/WebChannel.ts

@@ -177,11 +177,13 @@ export const messagePortChannelWithAck: {
       const ChannelRequest = Schema.TaggedStruct('ChannelRequest', {
         id: Schema.String,
         payload: Schema.Union(schema.listen, schema.send),
-      })
+      }).annotations({ title: 'webmesh.ChannelRequest' })
       const ChannelRequestAck = Schema.TaggedStruct('ChannelRequestAck', {
         reqId: Schema.String,
+      }).annotations({ title: 'webmesh.ChannelRequestAck' })
+      const ChannelMessage = Schema.Union(ChannelRequest, ChannelRequestAck).annotations({
+        title: 'webmesh.ChannelMessage',
       })
-      const ChannelMessage = Schema.Union(ChannelRequest, ChannelRequestAck)
       type ChannelMessage = typeof ChannelMessage.Type
 
       const debugInfo = {

package/src/effect/WebChannel/common.ts

@@ -43,7 +43,7 @@ export const mapSchema = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>,
 ): OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> =>
   Predicate.hasProperty(schema, 'send') && Predicate.hasProperty(schema, 'listen')
-    ? schemaWithDebugPing(schema)
+    ? (schemaWithDebugPing(schema) as any)
     : (schemaWithDebugPing({ send: schema, listen: schema }) as any)
 
 export const listenToDebugPing = (channelName: string) => {

package/src/effect/WebSocket.test.ts

@@ -0,0 +1,14 @@
+import * as Vitest from '@effect/vitest'
+import { Effect, Exit } from 'effect'
+
+import { makeWebSocket } from './WebSocket.js'
+
+Vitest.describe('WebSocket', () => {
+  Vitest.scopedLive(
+    'should create a WebSocket connection',
+    Effect.fn(function* () {
+      const exit = yield* makeWebSocket({ url: 'ws://localhost:1000' }).pipe(Effect.timeout(500), Effect.exit)
+      Vitest.expect(Exit.isFailure(exit)).toBe(true)
+    }),
+  )
+})

package/src/effect/WebSocket.ts

@@ -22,50 +22,69 @@ export const makeWebSocket = ({
   reconnect?: Schedule.Schedule<unknown> | false
 }): Effect.Effect<globalThis.WebSocket, WebSocketError, Scope.Scope> =>
   Effect.gen(function* () {
-    const socket = yield* Effect.tryPromise({
-      try: async () => {
-        // console.debug('[WebSocket] connecting to', url)
+    const socket = yield* Effect.async<globalThis.WebSocket, WebSocketError>((cb, signal) => {
+      try {
         const socket = new globalThis.WebSocket(url)
 
         if (socket.readyState === globalThis.WebSocket.OPEN) {
-          return socket
+          cb(Effect.succeed(socket))
+          return
         }
 
-        return await new Promise<globalThis.WebSocket>((resolve, reject) => {
-          socket.addEventListener('open', () => resolve(socket), { once: true })
-          // eslint-disable-next-line unicorn/prefer-add-event-listener
-          socket.onerror = (event) => reject(event)
+        signal.addEventListener('abort', () => {
+          socket.close(3000, 'abort signal')
         })
-      },
-      catch: (errorEvent: any) => {
-        if (errorEvent.currentTarget != null && errorEvent.currentTarget instanceof globalThis.WebSocket) {
-          errorEvent.currentTarget.close(3000, `closing websocket connection due to error: ${errorEvent.toString()}`)
-        }
 
-        return new WebSocketError({ cause: errorEvent })
-      },
-    }).pipe(
-      /**
-       * Common WebSocket close codes: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
-       *   1000: Normal closure
-       *   1001: Endpoint is going away, a server is terminating the connection because it has received a request that indicates the client is ending the connection.
-       *   1002: Protocol error, a server is terminating the connection because it has received data on the connection that was not consistent with the type of the connection.
-       *   1011: Internal server error, a server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
-       *
-       * For reference, here are the valid WebSocket close code ranges:
-       *   1000-1999: Reserved for protocol usage
-       *   2000-2999: Reserved for WebSocket extensions
-       *   3000-3999: Available for libraries and frameworks
-       *   4000-4999: Available for applications
-       */
-      Effect.acquireRelease((socket, exit) =>
-        Effect.sync(() =>
-          Exit.isFailure(exit)
-            ? socket.close(3000, `closing webmesh websocket connection due to error: ${exit.cause.toString()}`)
-            : socket.close(1000, 'closing webmesh websocket connection gracefully'),
-        ),
-      ),
-      reconnect ? Effect.retry(reconnect) : identity,
+        socket.addEventListener('open', () => cb(Effect.succeed(socket)), { once: true })
+
+        socket.addEventListener(
+          'error',
+          (event) => {
+            cb(Effect.fail(new WebSocketError({ cause: event })))
+          },
+          { once: true },
+        )
+
+        socket.addEventListener(
+          'close',
+          (event) => {
+            // console.log('makeWebSocket:socket:onclose', event)
+            return cb(Effect.fail(new WebSocketError({ cause: event })))
+          },
+          { once: true },
+        )
+
+        // console.log('makeWebSocket:socket:waiting for open', url)
+      } catch (error) {
+        cb(Effect.fail(new WebSocketError({ cause: error })))
+      }
+    }).pipe(reconnect ? Effect.retry(reconnect) : identity)
+
+    /**
+     * Common WebSocket close codes: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
+     *   1000: Normal closure
+     *   1001: Endpoint is going away, a server is terminating the connection because it has received a request that indicates the client is ending the connection.
+     *   1002: Protocol error, a server is terminating the connection because it has received data on the connection that was not consistent with the type of the connection.
+     *   1011: Internal server error, a server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
+     *
+     * For reference, here are the valid WebSocket close code ranges:
+     *   1000-1999: Reserved for protocol usage
+     *   2000-2999: Reserved for WebSocket extensions
+     *   3000-3999: Available for libraries and frameworks
+     *   4000-4999: Available for applications
+     */
+    yield* Effect.addFinalizer((exit) =>
+      Effect.async<void, WebSocketError>((cb) => {
+        try {
+          if (Exit.isFailure(exit)) {
+            socket.close(3000)
+          } else {
+            socket.close(1000)
+          }
+        } catch (error) {
+          cb(Effect.fail(new WebSocketError({ cause: error })))
+        }
+      }).pipe(Effect.orDie),
     )
 
     return socket

package/src/env.ts

@@ -26,7 +26,8 @@ export const isDevEnv = () => {
   return false
 }
 
-export const TRACE_VERBOSE = env('LS_TRACE_VERBOSE') !== undefined || env('VITE_LS_TRACE_VERBOSE') !== undefined
+export const TRACE_VERBOSE = true
+// export const TRACE_VERBOSE = env('LS_TRACE_VERBOSE') !== undefined || env('VITE_LS_TRACE_VERBOSE') !== undefined
 
 export const LS_DEV = env('LS_DEV') !== undefined || env('VITE_LS_DEV') !== undefined
 

package/src/node/ChildProcessRunner/ChildProcessRunner.ts

@@ -3,7 +3,6 @@ import process from 'node:process'
 
 import { WorkerError } from '@effect/platform/WorkerError'
 import * as Runner from '@effect/platform/WorkerRunner'
-import { Cause } from 'effect'
 import * as Context from 'effect/Context'
 import * as Deferred from 'effect/Deferred'
 import * as Effect from 'effect/Effect'
@@ -38,10 +37,12 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
         const runFork = Runtime.runFork(runtime)
         const onExit = (exit: Exit.Exit<any, E>) => {
           if (exit._tag === 'Failure') {
-            Deferred.unsafeDone(closeLatch, Exit.die(Cause.squash(exit.cause)))
+            // Deferred.unsafeDone(closeLatch, Exit.die(Cause.squash(exit.cause)))
+            Deferred.unsafeDone(closeLatch, Exit.die(exit.cause))
           }
         }
         port.on('message', (message: Runner.BackingRunner.Message<I>) => {
+          // console.log('message', message)
           if (message[0] === 0) {
             const fiber = runFork(handler(0, message[1]))
             fiber.addObserver(onExit)
@@ -49,11 +50,6 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
           } else {
             Deferred.unsafeDone(closeLatch, Exit.void)
             port.close()
-            // TODO get rid of this timeout (needs help from Tim Smart)
-            setTimeout(() => {
-              // eslint-disable-next-line unicorn/no-process-exit
-              process.exit(0)
-            }, 1000)
           }
         })
         port.on('messageerror', (cause) => {

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/ChildProcessRunner.test.ts

@@ -0,0 +1,52 @@
+// import * as WorkerThreads from 'node:worker_threads'
+import * as ChildProcess from 'node:child_process'
+
+import * as EffectWorker from '@effect/platform/Worker'
+import { assert, describe, it } from '@effect/vitest'
+import { Chunk, Effect, Stream } from 'effect'
+
+import * as ChildProcessWorker from '../ChildProcessWorker.js'
+import type { WorkerMessage } from './schema.js'
+import { GetPersonById, GetUserById, InitialMessage, Person, User } from './schema.js'
+
+const WorkerLive = ChildProcessWorker.layer(() =>
+  ChildProcess.fork(
+    new URL('../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js', import.meta.url),
+  ),
+)
+
+// const WorkerLive = NodeWorker.layer(
+//   () =>
+//     new WorkerThreads.Worker(
+//       new URL('../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js', import.meta.url),
+//     ),
+// )
+
+describe('ChildProcessRunner', { timeout: 10_000 }, () => {
+  it('Serialized', () =>
+    Effect.gen(function* () {
+      const pool = yield* EffectWorker.makePoolSerialized({ size: 1 })
+      const people = yield* pool.execute(new GetPersonById({ id: 123 })).pipe(Stream.runCollect)
+      assert.deepStrictEqual(Chunk.toReadonlyArray(people), [
+        new Person({ id: 123, name: 'test', data: new Uint8Array([1, 2, 3]) }),
+        new Person({ id: 123, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
+      ])
+    }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
+
+  it('Serialized with initialMessage', () =>
+    Effect.gen(function* () {
+      const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
+        size: 1,
+        initialMessage: () => new InitialMessage({ name: 'custom', data: new Uint8Array([1, 2, 3]) }),
+      })
+
+      let user = yield* pool.executeEffect(new GetUserById({ id: 123 }))
+      user = yield* pool.executeEffect(new GetUserById({ id: 123 }))
+      assert.deepStrictEqual(user, new User({ id: 123, name: 'custom' }))
+      const people = yield* pool.execute(new GetPersonById({ id: 123 })).pipe(Stream.runCollect)
+      assert.deepStrictEqual(Chunk.toReadonlyArray(people), [
+        new Person({ id: 123, name: 'test', data: new Uint8Array([1, 2, 3]) }),
+        new Person({ id: 123, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
+      ])
+    }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
+})

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/schema.ts

@@ -0,0 +1,65 @@
+// import * as Transferable from '@effect/platform/Transferable'
+import * as Schema from 'effect/Schema'
+
+export class User extends Schema.Class<User>('User')({
+  id: Schema.Number,
+  name: Schema.String,
+}) {}
+
+export class GetUserById extends Schema.TaggedRequest<GetUserById>()('GetUserById', {
+  failure: Schema.Never,
+  success: User,
+  payload: {
+    id: Schema.Number,
+  },
+}) {}
+
+export class Person extends Schema.Class<Person>('Person')({
+  id: Schema.Number,
+  name: Schema.String,
+  // data: Transferable.Uint8Array,
+  data: Schema.Uint8Array,
+}) {}
+
+export class GetPersonById extends Schema.TaggedRequest<GetPersonById>()('GetPersonById', {
+  failure: Schema.Never,
+  success: Person,
+  payload: {
+    id: Schema.Number,
+  },
+}) {}
+
+export class RunnerInterrupt extends Schema.TaggedRequest<RunnerInterrupt>()('RunnerInterrupt', {
+  failure: Schema.Never,
+  success: Schema.Void,
+  payload: {},
+}) {}
+
+export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
+  failure: Schema.Never,
+  success: Schema.Void,
+  payload: {
+    name: Schema.String,
+    data: Schema.Uint8Array,
+    // data: Transferable.Uint8Array,
+  },
+}) {}
+
+export class GetSpan extends Schema.TaggedRequest<GetSpan>()('GetSpan', {
+  failure: Schema.Never,
+  success: Schema.Struct({
+    name: Schema.String,
+    traceId: Schema.String,
+    spanId: Schema.String,
+    parent: Schema.Option(
+      Schema.Struct({
+        traceId: Schema.String,
+        spanId: Schema.String,
+      }),
+    ),
+  }),
+  payload: {},
+}) {}
+
+export const WorkerMessage = Schema.Union(GetUserById, GetPersonById, InitialMessage, GetSpan, RunnerInterrupt)
+export type WorkerMessage = Schema.Schema.Type<typeof WorkerMessage>

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.ts

@@ -0,0 +1,53 @@
+import * as Runner from '@effect/platform/WorkerRunner'
+import { Context, Effect, Layer, Option, Stream } from 'effect'
+
+// import { NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
+import { PlatformNode } from '../../mod.js'
+import * as ChildProcessRunner from '../ChildProcessRunner.js'
+import { Person, User, WorkerMessage } from './schema.js'
+
+interface Name {
+  readonly _: unique symbol
+}
+const Name = Context.GenericTag<Name, string>('Name')
+
+const WorkerLive = Runner.layerSerialized(WorkerMessage, {
+  GetPersonById: (req) => {
+    return Stream.make(
+      new Person({ id: req.id, name: 'test', data: new Uint8Array([1, 2, 3]) }),
+      new Person({ id: req.id, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
+    )
+  },
+  GetUserById: (req) => Effect.map(Name, (name) => new User({ id: req.id, name })),
+  // InitialMessage: (req) => Layer.succeed(Name, req.name),
+  InitialMessage: (req) =>
+    Effect.gen(function* () {
+      yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
+      return Layer.succeed(Name, req.name)
+    }).pipe(Layer.unwrapScoped),
+  // InitialMessage: (req) =>
+  //   Layer.scoped(
+  //     Name,
+  //     Effect.gen(function* () {
+  //       yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
+  //       return req.name
+  //     }),
+  //   ),
+  GetSpan: (_) =>
+    Effect.gen(function* (_) {
+      const span = yield* _(Effect.currentSpan, Effect.orDie)
+      return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        name: span.name,
+        parent: Option.map(span.parent, (span) => ({
+          traceId: span.traceId,
+          spanId: span.spanId,
+        })),
+      }
+    }).pipe(Effect.withSpan('GetSpan')),
+  RunnerInterrupt: () => Effect.interrupt,
+}).pipe(Layer.provide(ChildProcessRunner.layer))
+// }).pipe(Layer.provide(PlatformNode.NodeWorkerRunner.layer))
+
+PlatformNode.NodeRuntime.runMain(Runner.launch(WorkerLive))

package/src/node/ChildProcessRunner/ChildProcessWorker.ts

@@ -1,9 +1,9 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
-import type * as ChildProcess from 'node:child_process'
-
 import * as Worker from '@effect/platform/Worker'
 import { WorkerError } from '@effect/platform/WorkerError'
+// eslint-disable-next-line unicorn/prefer-node-protocol
+import type * as ChildProcess from 'child_process'
 import * as Deferred from 'effect/Deferred'
 import * as Effect from 'effect/Effect'
 import * as Exit from 'effect/Exit'

package/src/node/mod.ts

@@ -1,3 +1,5 @@
+import * as http from 'node:http'
+
 import * as OtelNodeSdk from '@effect/opentelemetry/NodeSdk'
 import type * as otel from '@opentelemetry/api'
 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http'
@@ -8,7 +10,7 @@ import { Config, Effect, Layer } from 'effect'
 import type { ParentSpan } from 'effect/Tracer'
 
 import { tapCauseLogPretty } from '../effect/Effect.js'
-import { OtelTracer } from '../effect/index.js'
+import { OtelTracer, UnknownError } from '../effect/index.js'
 import { makeNoopTracer } from '../NoopTracer.js'
 
 // import { tapCauseLogPretty } from '../effect/Effect.js'
@@ -30,6 +32,31 @@ export * as ChildProcessWorker from './ChildProcessRunner/ChildProcessWorker.js'
 
 // export const OtelLiveHttp = (args: any): Layer.Layer<never> => Layer.empty
 
+export const getFreePort = Effect.async<number, UnknownError>((cb, signal) => {
+  const server = http.createServer()
+
+  signal.addEventListener('abort', () => {
+    server.close()
+  })
+
+  // Listen on port 0 to get an available port
+  server.listen(0, () => {
+    const address = server.address()
+
+    if (address && typeof address === 'object') {
+      const port = address.port
+      server.close(() => cb(Effect.succeed(port)))
+    } else {
+      server.close(() => cb(Effect.fail(new UnknownError({ cause: 'Failed to get a free port' }))))
+    }
+  })
+
+  // Error handling in case the server encounters an error
+  server.on('error', (err) => {
+    server.close(() => cb(Effect.fail(new UnknownError({ cause: err }))))
+  })
+})
+
 export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend(() => {
   const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, makeNoopTracer())
 
@@ -91,12 +118,12 @@ export const logTraceUiUrlForSpan = (printMsg?: (url: string) => string) => (spa
   getTracingBackendUrl(span).pipe(
     Effect.tap((url) => {
       if (url === undefined) {
-        console.warn('No tracing backend url found')
+        return Effect.logWarning('No tracing backend url found')
       } else {
         if (printMsg) {
-          console.log(printMsg(url))
+          return Effect.log(printMsg(url))
         } else {
-          console.log(`Trace URL: ${url}`)
+          return Effect.log(`Trace URL: ${url}`)
         }
       }
     }),