@effect-app/infra 1.23.2 → 1.23.4

package/src/api/routing/makeRequestHandler.ts

@@ -15,6 +15,7 @@ import type { HttpServerError } from "effect-app/http"
 import { HttpBody, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect-app/http"
 import { NonEmptyString255 } from "effect-app/schema"
 import type { REST } from "effect-app/schema"
+import { InfraLogger } from "../../logger.js"
 import { updateRequestContext } from "../setupRequest.js"
 import { makeRequestParsers, parseRequestParams } from "./base.js"
 import type { RequestHandler, RequestHandlerBase } from "./base.js"
@@ -170,19 +171,19 @@ export function makeRequestHandler<
   )
 
   return Effect
-    .gen(function*($) {
-      const req = yield* $(HttpServerRequest.HttpServerRequest)
+    .gen(function*() {
+      const req = yield* HttpServerRequest.HttpServerRequest
       const res = HttpServerResponse
         .empty()
         .pipe((_) => req.method === "GET" ? HttpServerResponse.setHeader(_, "Cache-Control", "no-store") : _)
 
-      const pars = yield* $(getParams)
+      const pars = yield* getParams
 
-      const settings = yield* $(FiberRef.get(RequestSettings))
+      const settings = yield* FiberRef.get(RequestSettings)
 
       const eff =
         // TODO: we don;t have access to user id here cause context is not yet created
-        Effect
+        InfraLogger
           .logInfo("Incoming request")
           .pipe(
             Effect.annotateLogs({
@@ -281,7 +282,7 @@ export function makeRequestHandler<
                           }),
                           Effect.suspend(() => {
                             const headers = res.headers
-                            return Effect
+                            return InfraLogger
                               .logError("Finished request", cause)
                               .pipe(Effect.annotateLogs({
                                 method: req.method,
@@ -312,7 +313,7 @@ export function makeRequestHandler<
               ),
             Effect
               .tap((res) =>
-                Effect
+                InfraLogger
                   .logInfo("Finished request")
                   .pipe(Effect.annotateLogs({
                     method: req.method,
@@ -327,7 +328,7 @@ export function makeRequestHandler<
               )
           )
 
-      return yield* $(eff)
+      return yield* eff
     })
     .pipe((_) =>
       updateRequestContext(

package/src/api/writeDocs.ts.bak

@@ -27,5 +27,5 @@ export function writeOpenapiDocsI(rdescs: readonly RouteDescriptorAny[]) {
       ]
     }))
     .flatMap((_) => writeTextFile("./openapi.json", JSON.stringify(_, undefined, 2)).orDie)
-    .flatMap(() => Effect.logDebug("OpenAPI spec written to './openapi.json'"))
+    .flatMap(() => InfraLogger.logDebug("OpenAPI spec written to './openapi.json'"))
 }

package/src/errorReporter.ts

@@ -2,6 +2,7 @@ import { dropUndefined } from "@effect-app/core/utils"
 import * as Sentry from "@sentry/node"
 import { Cause, Effect, Option } from "effect-app"
 import { annotateSpanWithError, CauseException, ErrorReported } from "./errors.js"
+import { InfraLogger } from "./logger.js"
 import { RequestContextContainer } from "./services/RequestContextContainer.js"
 
 const tryToJson = <T>(error: CauseException<T>) => {
@@ -24,28 +25,27 @@ export function reportError(
   name: string
 ) {
   return (cause: Cause<unknown>, extras?: Record<string, unknown>) =>
-    Effect.gen(function*($) {
-      yield* $(annotateSpanWithError(cause, name))
+    Effect.gen(function*() {
+      yield* annotateSpanWithError(cause, name)
       if (Cause.isInterrupted(cause)) {
-        yield* $(Effect.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {}))))
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
         return
       }
       const error = new CauseException(cause, name)
 
-      yield* $(reportSentry(error, extras))
-      yield* $(
-        Effect
-          .logError("Reporting error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              __cause__: tryToJson(error),
-              __error_name__: name
-            })),
-            Effect.catchAllCause((cause) => Effect.logError("Failed to log error", cause)),
-            Effect.catchAllCause(() => Effect.logError("Failed to log error cause"))
-          )
-      )
+      yield* reportSentry(error, extras)
+      yield* InfraLogger
+        .logError("Reporting error", cause)
+        .pipe(
+          Effect.annotateLogs(dropUndefined({
+            extras,
+            __cause__: tryToJson(error),
+            __error_name__: name
+          })),
+          Effect.catchAllCause((cause) => InfraLogger.logError("Failed to log error", cause)),
+          Effect.catchAllCause(() => InfraLogger.logError("Failed to log error cause"))
+        )
+
       error[ErrorReported] = true
       return error
     })
@@ -69,25 +69,23 @@ export function logError<E>(
   name: string
 ) {
   return (cause: Cause<E>, extras?: Record<string, unknown>) =>
-    Effect.gen(function*($) {
+    Effect.gen(function*() {
       if (Cause.isInterrupted(cause)) {
-        yield* $(Effect.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras }))))
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
         return
       }
       const error = new CauseException(cause, name)
-      yield* $(
-        Effect
-          .logWarning("Logging error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              __cause__: tryToJson(error),
-              __error_name__: name
-            })),
-            Effect.catchAllCause((cause) => Effect.logError("Failed to log error", cause)),
-            Effect.catchAllCause(() => Effect.logError("Failed to log error cause"))
-          )
-      )
+      yield* InfraLogger
+        .logWarning("Logging error", cause)
+        .pipe(
+          Effect.annotateLogs(dropUndefined({
+            extras,
+            __cause__: tryToJson(error),
+            __error_name__: name
+          })),
+          Effect.catchAllCause((cause) => InfraLogger.logError("Failed to log error", cause)),
+          Effect.catchAllCause(() => InfraLogger.logError("Failed to log error cause"))
+        )
     })
 }
 
@@ -96,7 +94,7 @@ export function captureException(error: unknown) {
   console.error(error)
 }
 
-export function reportMessage(message: string, extras?: Record<string, unknown> | undefined) {
+export function reportMessage(message: string, extras?: Record<string, unknown>) {
   return RequestContextContainer.getOption.pipe(Effect.map((ctx) => {
     const context = Option.getOrUndefined(ctx)
     const scope = new Sentry.Scope()

package/src/logger.ts

@@ -0,0 +1,3 @@
+import { makeLog } from "@effect-app/core/utils/logger"
+
+export const InfraLogger = makeLog("@effect-app/infra", "info")

package/src/services/Emailer/Sendgrid.ts

@@ -3,6 +3,7 @@ import type { EmailData } from "@sendgrid/helpers/classes/email-address.js"
 import sgMail from "@sendgrid/mail"
 import { Array, Effect, Equivalence, Secret } from "effect-app"
 import { inspect } from "util"
+import { InfraLogger } from "../../logger.js"
 import { Emailer } from "./service.js"
 import type { EmailMsg, EmailMsgOptionalFrom, SendgridConfig } from "./service.js"
 
@@ -12,7 +13,7 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
 
     return Emailer.of({
       sendMail(msg_: EmailMsgOptionalFrom) {
-        return Effect.gen(function*($) {
+        return Effect.gen(function*() {
           const msg: EmailMsg = dropUndefinedT({
             ...msg_,
             from: msg_.from ?? defaultFrom,
@@ -22,16 +23,17 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
 
           const renderedMsg_ = render(msg)
           const renderedMsg = { ...renderedMsg_, subject: `${subjectPrefix}${renderedMsg_.subject}` }
-          yield* $(Effect.logDebug("Sending email").pipe(Effect.annotateLogs("msg", inspect(renderedMsg, false, 5))))
+          yield* InfraLogger.logDebug("Sending email").pipe(Effect.annotateLogs("msg", inspect(renderedMsg, false, 5)))
 
-          const ret = yield* $(
-            Effect.async<[sgMail.ClientResponse, Record<string, unknown>], Error | sgMail.ResponseError>(
-              (cb) =>
-                void sgMail.send(renderedMsg, false, (err, result) =>
-                  err
-                    ? cb(Effect.fail(err))
-                    : cb(Effect.sync(() => result)))
-            )
+          const ret = yield* Effect.async<
+            [sgMail.ClientResponse, Record<string, unknown>],
+            Error | sgMail.ResponseError
+          >(
+            (cb) =>
+              void sgMail.send(renderedMsg, false, (err, result) =>
+                err
+                  ? cb(Effect.fail(err))
+                  : cb(Effect.sync(() => result)))
           )
 
           // const event = {
@@ -40,8 +42,8 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
           //     templateId: msg.templateId
           //   }
           // }
-          // yield* $(Effect.logDebug("Tracking email event").annotateLogs("event", event.$$.pretty))
-          // const { trackEvent } = yield* $(AiContextService)
+          // yield* InfraLogger.logDebug("Tracking email event").annotateLogs("event", event.$$.pretty)
+          // const { trackEvent } = yield* AiContextService
           // trackEvent(event)
           return ret
         })

package/src/services/Emailer/fake.ts

@@ -1,13 +1,14 @@
 import { Effect } from "effect-app"
 import { pretty } from "effect-app/utils"
+import { InfraLogger } from "../../logger.js"
 import { Emailer } from "./service.js"
 
-const makeFake = Effect
-  .logDebug("FAKE Emailer Service enabled")
+const makeFake = InfraLogger
+  .logInfo("FAKE Emailer Service enabled")
   .pipe(Effect.map(() =>
     Emailer.of({
       sendMail(msg) {
-        return Effect
+        return InfraLogger
           .logDebug(`Fake send mail`)
           .pipe(Effect.annotateLogs("msg", pretty(msg)))
       }

package/src/services/QueueMaker/SQLQueue.ts

@@ -10,6 +10,7 @@ import { Effect, Fiber, Option, S, Tracer } from "effect-app"
 import { RequestId } from "effect-app/ids"
 import { NonEmptyString255 } from "effect-app/schema"
 import { pretty } from "effect-app/utils"
+import { InfraLogger } from "../../logger.js"
 
 export const QueueId = S.Number.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type
@@ -113,23 +114,21 @@ export function makeSQLQueue<
     return {
       publish: (...messages) =>
         Effect
-          .gen(function*($) {
-            const requestContext = yield* $(rcc.requestContext)
-            const span = yield* $(Effect.serviceOption(Tracer.ParentSpan))
-            return yield* $(
-              Effect
-                .forEach(
-                  messages,
-                  (m) =>
-                    q.offer(m, {
-                      requestContext: new RequestContext(requestContext), // workaround Schema expecting exact class
-                      span: Option.getOrUndefined(span)
-                    }),
-                  {
-                    discard: true
-                  }
-                )
-            )
+          .gen(function*() {
+            const requestContext = yield* rcc.requestContext
+            const span = yield* Effect.serviceOption(Tracer.ParentSpan)
+            return yield* Effect
+              .forEach(
+                messages,
+                (m) =>
+                  q.offer(m, {
+                    requestContext: new RequestContext(requestContext), // workaround Schema expecting exact class
+                    span: Option.getOrUndefined(span)
+                  }),
+                {
+                  discard: true
+                }
+              )
           })
           .pipe(
             Effect.withSpan("queue.publish: " + queueName, {
@@ -149,8 +148,8 @@ export function makeSQLQueue<
               .succeed(msg)
               .pipe(Effect
                 .flatMap(({ body, meta }) => {
-                  let effect = Effect
-                    .logDebug(`[${queueDrainName}] Processing incoming message`)
+                  let effect = InfraLogger
+                    .logInfo(`[${queueDrainName}] Processing incoming message`)
                     .pipe(
                       Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
                       Effect.zipRight(handleEvent(body)),

package/src/services/QueueMaker/memQueue.ts

@@ -6,6 +6,7 @@ import { Effect, Fiber, flow, Option, S } from "effect-app"
 import { RequestId } from "effect-app/ids"
 import { pretty } from "effect-app/utils"
 import { setupRequestContext } from "../../api/setupRequest.js"
+import { InfraLogger } from "../../logger.js"
 import { RequestContextContainer } from "../RequestContextContainer.js"
 import { reportNonInterruptedFailure } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
@@ -24,11 +25,11 @@ export function makeMemQueue<
   schema: S.Schema<Evt, EvtE>,
   drainSchema: S.Schema<DrainEvt, DrainEvtE>
 ) {
-  return Effect.gen(function*($) {
-    const mem = yield* $(MemQueue)
-    const q = yield* $(mem.getOrCreateQueue(queueName))
-    const qDrain = yield* $(mem.getOrCreateQueue(queueDrainName))
-    const rcc = yield* $(RequestContextContainer)
+  return Effect.gen(function*() {
+    const mem = yield* MemQueue
+    const q = yield* mem.getOrCreateQueue(queueName)
+    const qDrain = yield* mem.getOrCreateQueue(queueDrainName)
+    const rcc = yield* RequestContextContainer
 
     const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
     const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
@@ -37,21 +38,19 @@ export function makeMemQueue<
     return {
       publish: (...messages) =>
         Effect
-          .gen(function*($) {
-            const requestContext = yield* $(rcc.requestContext)
-            const span = yield* $(Effect.serviceOption(Tracer.ParentSpan))
-            return yield* $(
-              Effect
-                .forEach(messages, (m) =>
-                  // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-                  S.encode(wireSchema)({ body: m, meta: { requestContext, span: Option.getOrUndefined(span) } }).pipe(
-                    Effect.orDie,
-                    Effect
-                      .andThen(JSON.stringify),
-                    // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
-                    Effect.flatMap((_) => q.offer(_))
-                  ), { discard: true })
-            )
+          .gen(function*() {
+            const requestContext = yield* rcc.requestContext
+            const span = yield* Effect.serviceOption(Tracer.ParentSpan)
+            return yield* Effect
+              .forEach(messages, (m) =>
+                // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
+                S.encode(wireSchema)({ body: m, meta: { requestContext, span: Option.getOrUndefined(span) } }).pipe(
+                  Effect.orDie,
+                  Effect
+                    .andThen(JSON.stringify),
+                  // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
+                  Effect.flatMap((_) => q.offer(_))
+                ), { discard: true })
           })
           .pipe(
             Effect.withSpan("queue.publish: " + queueName, {
@@ -64,7 +63,7 @@ export function makeMemQueue<
         handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>,
         sessionId?: string
       ) =>
-        Effect.gen(function*($) {
+        Effect.gen(function*() {
           const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
           const processMessage = (msg: string) =>
             // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
@@ -75,8 +74,8 @@ export function makeMemQueue<
                 Effect.orDie,
                 Effect
                   .flatMap(({ body, meta }) => {
-                    let effect = Effect
-                      .logDebug(`[${queueDrainName}] Processing incoming message`)
+                    let effect = InfraLogger
+                      .logInfo(`[${queueDrainName}] Processing incoming message`)
                       .pipe(
                         Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
                         Effect.zipRight(handleEvent(body)),
@@ -107,19 +106,17 @@ export function makeMemQueue<
                     return effect
                   })
               )
-          return yield* $(
-            qDrain
-              .take
-              .pipe(
-                Effect.flatMap((x) =>
-                  processMessage(x).pipe(Effect.uninterruptible, Effect.fork, Effect.flatMap(Fiber.join))
-                ),
-                // TODO: normally a failed item would be returned to the queue and retried up to X times.
-                // .flatMap(_ => _._tag === "Failure" && !isInterrupted ? qDrain.offer(x) : Effect.unit) // TODO: retry count tracking and max retries.
-                silenceAndReportError,
-                Effect.forever
-              )
-          )
+          return yield* qDrain
+            .take
+            .pipe(
+              Effect.flatMap((x) =>
+                processMessage(x).pipe(Effect.uninterruptible, Effect.fork, Effect.flatMap(Fiber.join))
+              ),
+              // TODO: normally a failed item would be returned to the queue and retried up to X times.
+              // .flatMap(_ => _._tag === "Failure" && !isInterrupted ? qDrain.offer(x) : Effect.unit) // TODO: retry count tracking and max retries.
+              silenceAndReportError,
+              Effect.forever
+            )
         })
     } satisfies QueueBase<Evt, DrainEvt>
   })

package/src/services/QueueMaker/sbqueue.ts

@@ -14,6 +14,7 @@ import type { StringId } from "effect-app/schema"
 import { NonEmptyString255 } from "effect-app/schema"
 import { pretty } from "effect-app/utils"
 import { setupRequestContext } from "../../api/setupRequest.js"
+import { InfraLogger } from "../../logger.js"
 import { RequestContextContainer } from "../RequestContextContainer.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
@@ -39,16 +40,16 @@ export function makeServiceBusQueue<
   const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
   const parseDrain = flow(S.decodeUnknown(drainW), Effect.orDie)
 
-  return Effect.gen(function*($) {
-    const s = yield* $(Sender)
-    const receiver = yield* $(ServiceBusReceiverFactory)
+  return Effect.gen(function*() {
+    const s = yield* Sender
+    const receiver = yield* ServiceBusReceiverFactory
     const silenceAndReportError = reportNonInterruptedFailure({ name: "ServiceBusQueue.drain." + queueDrainName })
     const reportError = reportNonInterruptedFailureCause({ name: "ServiceBusQueue.drain." + queueDrainName })
-    const rcc = yield* $(RequestContextContainer)
+    const rcc = yield* RequestContextContainer
 
     // TODO: or do async?
     // This will make sure that the host receives the error (MainFiberSet.join), who will then interrupt everything and commence a shutdown and restart of app
-    // const deferred = yield* $(Deferred.make<never, ServiceBusError | Error>())
+    // const deferred = yield* Deferred.make<never, ServiceBusError | Error>()
 
     return {
       drain: <DrainE, DrainR>(
@@ -56,7 +57,7 @@ export function makeServiceBusQueue<
         sessionId?: string
       ) =>
         Effect
-          .gen(function*($) {
+          .gen(function*() {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             function processMessage(messageBody: any) {
               return Effect
@@ -66,8 +67,8 @@ export function makeServiceBusQueue<
                   Effect.orDie,
                   Effect
                     .flatMap(({ body, meta }) => {
-                      let effect = Effect
-                        .logDebug(`[${queueDrainName}] Processing incoming message`)
+                      let effect = InfraLogger
+                        .logInfo(`[${queueDrainName}] Processing incoming message`)
                         .pipe(
                           Effect.annotateLogs({
                             body: pretty(body),
@@ -113,46 +114,42 @@ export function makeServiceBusQueue<
                 )
             }
 
-            return yield* $(
-              subscribe({
-                processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
-                processError: (err) => reportQueueError(Cause.fail(err.error))
-                // Deferred.completeWith(
-                //   deferred,
-                //   reportFatalQueueError(Cause.fail(err.error))
-                //     .pipe(Effect.andThen(Effect.fail(err.error)))
-                // )
-              }, sessionId)
-                .pipe(Effect.provideService(ServiceBusReceiverFactory, receiver))
-            )
+            return yield* subscribe({
+              processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
+              processError: (err) => reportQueueError(Cause.fail(err.error))
+              // Deferred.completeWith(
+              //   deferred,
+              //   reportFatalQueueError(Cause.fail(err.error))
+              //     .pipe(Effect.andThen(Effect.fail(err.error)))
+              // )
+            }, sessionId)
+              .pipe(Effect.provideService(ServiceBusReceiverFactory, receiver))
           })
           // .pipe(Effect.andThen(Deferred.await(deferred).pipe(Effect.orDie))),
           .pipe(Effect.andThen(Effect.never)),
 
       publish: (...messages) =>
         Effect
-          .gen(function*($) {
-            const requestContext = yield* $(rcc.requestContext)
-            const span = yield* $(Effect.serviceOption(Tracer.ParentSpan))
-            return yield* $(
-              Effect
-                .promise((abortSignal) =>
-                  s.sendMessages(
-                    messages.map((m) => ({
-                      body: JSON.stringify(
-                        S.encodeSync(wireSchema)({
-                          body: m,
-                          meta: { requestContext, span: Option.getOrUndefined(span) }
-                        })
-                      ),
-                      messageId: m.id, /* correllationid: requestId */
-                      contentType: "application/json",
-                      sessionId: "sessionId" in m ? m.sessionId : undefined
-                    })),
-                    { abortSignal }
-                  )
+          .gen(function*() {
+            const requestContext = yield* rcc.requestContext
+            const span = yield* Effect.serviceOption(Tracer.ParentSpan)
+            return yield* Effect
+              .promise((abortSignal) =>
+                s.sendMessages(
+                  messages.map((m) => ({
+                    body: JSON.stringify(
+                      S.encodeSync(wireSchema)({
+                        body: m,
+                        meta: { requestContext, span: Option.getOrUndefined(span) }
+                      })
+                    ),
+                    messageId: m.id, /* correllationid: requestId */
+                    contentType: "application/json",
+                    sessionId: "sessionId" in m ? m.sessionId : undefined
+                  })),
+                  { abortSignal }
                 )
-            )
+              )
           })
           .pipe(Effect.withSpan("queue.publish: " + queueName, {
             captureStackTrace: false,