Using trypromise and logging the original error

[blntrsz]

Hey there, I started using Effect in a couple of week, and I'm curious what is the best way to use tryPromise and log the original error.

So what I do is:

Effect.gen(function* () {
  yield* Effect.tryPromise({
    try: () => callPromise(),
    catch: (error) => new MyCustomError({
      message: "My custom error",
      cause: error
    })
  })
})

And I want to log the error with Effect.logError, but cannot run effect in the catch. The best option I could find is the following, but feel like that's not the best option:

Effect.tryPromise(() => callPromise()).pipe(
    Effect.tapError((error) => Effect.logError((error as Error).message)),
    Effect.mapError(
      (error) =>
        new MyCustomError({
          message: "My custom error",
          cause: error,
        })
    ),
)

Could someone provide a better option for this? Thank you 🙏

[manimovassagh]

Your second approach is actually the idiomatic way to do this in Effect. The pattern of tryPromise -> tapError -> mapError is the standard pipeline. You can clean it up slightly:

const program = Effect.tryPromise(() => callPromise()).pipe(
  Effect.tapError((error) =>
    Effect.logError("callPromise failed", Cause.die(error))
  ),
  Effect.mapError(
    (error) =>
      new MyCustomError({
        message: "My custom error",
        cause: error,
      })
  )
);

If you want the original error preserved in structured logging (not just the message), use Effect.annotateLogs or pass the error as a cause:

const program = Effect.tryPromise(() => callPromise()).pipe(
  Effect.tapError((error) =>
    Effect.logError("callPromise failed").pipe(
      Effect.annotateLogs({ originalError: String(error) })
    )
  ),
  Effect.mapError(
    (error) =>
      new MyCustomError({
        message: "My custom error",
        cause: error,
      })
  )
);

Another option — if you want logging to happen automatically whenever this error type is encountered, you can use Effect.catchTag at a higher level:

// In a shared error handler / layer
const withErrorLogging = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
  effect.pipe(
    Effect.tapErrorCause((cause) => Effect.logError(cause))
  );

tapErrorCause gives you the full Cause which includes the stack trace and any nested causes — it's more informative than just logging the error message.

The reason you can't run Effect inside the catch callback of tryPromise is that catch is a synchronous mapper (unknown -> E). It's intentionally simple — the error mapping should be pure. Side effects like logging belong in the Effect pipeline via tapError.

So your second approach is the right one. The only thing I'd suggest is using tapErrorCause instead of tapError if you want the full error context including stack traces.