Stuck trying to embed a Log effect into Amazonka's flexible IO logger

[YourFin]

Hey, sorry for the newbie question here, but I've been banging my head against this for three days and some help would be appreciated. In short, I'm trying to convert a Log effect into Log.Message -> IO, and inject that into a Reader (Cfg { logger :: Log.Message -> IO () }) for a 3rd party library (Amazonka) such that the library's logs get handled by my dynamic Log effect. All my attempts to do so have resulted in a hang.

---

Long form:

My goal is to take a log effect I've written (based on Di-Df1):

data Log :: Effect where
  LogWithLevel :: Level -> Message -> Log m ()

Full `Log.hs` file

module Yf.Effect.Log (
  Log,

  -- Re-exports from other Log libs
  Level(..),
  Rate(..),

  -- Re-exports from DF1
  Path,
  Segment,
  ToSegment,
  Key,
  ToKey,
  Value,
  ToValue,
  Message,
  ToMessage,
  segment,
  key,
  value,
  message,

  -- Core effects
  attr_,
  push_,
  filter,
  logWithLevel,
  flush,
  askLogFn,

  -- Helpers

  attr,
  push,
  traceSensitive,
  debug,
  info,
  error,
  traceSensitive_,
  debug_,
  info_,
  error_,

  -- Runners
  runDiIO,
  runConsole,
  runConsole_,
  runNoop,
) where

import Prelude hiding (runReader, Reader, filter, error)
import Yf.Effect.Log.Level (Level(..), Rate(..))
import qualified Yf.Effect.Log.Level as Level

import Effectful (Effect, Eff, IOE, (:>), UnliftStrategy(ConcUnlift), Persistence(Persistent), Limit(Unlimited))
import qualified Effectful as Effectful
import Effectful.Dispatch.Dynamic (interpret, reinterpret, localUnlift, localSeqUnlift)
import Effectful.TH (makeEffect)

-- TODO: try swapping out for static
import Effectful.Reader.Dynamic (Reader(), runReader)
import qualified Effectful.Reader.Dynamic as Reader
import Di.Core (Di, log_level)
import qualified Di.Core as Di
import qualified Di.Handle as DiHandle
import qualified Di.Df1 as DiDf1
import Df1 (Path, Segment, ToSegment, Key, ToKey, Value, ToValue, Message, ToMessage, segment, key, value, message)
import Data.Sequence (Seq)

data Log :: Effect where
  Attr_ :: Key -> Value -> m a -> Log m a
  Push_ :: Segment -> m a -> Log m a
  Filter :: (Level -> Seq Path -> Message -> Bool) -> m a -> Log m a
  AskDi :: Log m (Di Level Path Message)
  LogWithLevel :: Level -> Message -> Log m ()
  Flush :: Log m ()
  AskLogFn :: (MonadIO w) => Log m (Level -> Message -> w ())
makeEffect ''Log

attr :: (ToValue v, Log :> es) => Key -> v -> Eff es a -> Eff es a
attr key val action = attr_ key (Df1.value val) action

push :: (ToSegment s, Log :> es) => s -> Eff es a -> Eff es a
push s action = push_ (segment s) action

traceSensitive :: (ToMessage msg, Log :> es) => msg -> Eff es ()
traceSensitive msg = logWithLevel TraceSensitive (message msg)

debug :: (ToMessage msg, Log :> es) => msg -> Eff es ()
debug msg = logWithLevel Debug (message msg)

info :: (ToMessage msg, Log :> es) => msg -> Eff es ()
info msg = logWithLevel Info (message msg)

error :: (ToMessage msg, Log :> es) => Rate -> msg -> Eff es ()
error rate msg = logWithLevel (Error rate) (message msg)

traceSensitive_ :: Log :> es => Message -> Eff es ()
traceSensitive_ msg = logWithLevel TraceSensitive (message msg)

debug_ :: Log :> es => Message -> Eff es ()
debug_ msg = logWithLevel Debug (message msg)

info_ :: Log :> es => Message -> Eff es ()
info_ msg = logWithLevel Info (message msg)

error_ :: Log :> es => Rate -> Message -> Eff es ()
error_ rate msg = logWithLevel (Error rate) (message msg)

runDiIO :: (IOE :> es) => Di Level Path Message -> Eff (Log : es) a -> Eff es a
runDiIO di =
  reinterpret (runReader di) $ \env -> \case
    Attr_ kk value action -> adaptDf1 (DiDf1.attr_ kk value) action env
    Push_ segment action -> adaptDf1 (DiDf1.push segment) action env
    Filter pred action -> adaptDf1 (Di.filter pred) action env
    LogWithLevel level msg -> do
      di' <- Reader.ask @(Di Level Path Message)
      Di.log di' level msg
    Flush -> do
      di' <- Reader.ask @(Di Level Path Message)
      Di.flush di'
    AskLogFn -> do
      di' <- Reader.ask @(Di Level Path Message)
      pure (Di.log di')
  where
    adaptDf1 modifyDf1 action env = do
      unliftStrat <- Effectful.unliftStrategy
      localUnlift env unliftStrat $ \unlift ->
        Reader.local @(Di Level Path Message) modifyDf1 $ unlift action

runConsole :: (IOE :> es) => Level -> Eff (Log : es) a -> Eff es a
runConsole level action = do
  writeLog <- DiHandle.stderr lineRenderer
  Di.new writeLog (\di -> runDiIO di $ do
                      val <- filteredAction
                      flush
                      pure val)
  where
    filteredAction = filter (\msgLevel _ _ -> msgLevel >= level) action

runConsole_ :: (IOE :> es) => Eff (Log : es) a -> Eff es a
runConsole_ = runConsole (Level.Error Level.Rate)

runNoop :: Eff (Log : es) a -> Eff es a
runNoop =
  interpret $ \env -> \case
    Attr_ _ _ action -> adapt action env
    Push_ _ action -> adapt action env
    Filter _ action -> adapt action env
    LogWithLevel _ _ -> pure ()
    Flush -> pure ()
    AskLogFn -> pure (\_ _ -> pure ())
  where
    adapt action env = localSeqUnlift env (\unlift ->
      unlift action)

-- TODO: systemd journal
-- https://github.com/ocharles/libsystemd-journal

lineRenderer :: DiHandle.LineRenderer Level Path Message
lineRenderer = DiHandle.LineRendererUtf8 render
  where
    renderDf1 = case DiDf1.df1 of
      DiHandle.LineRendererUtf8 renderDf1' -> renderDf1'
    render supportsColors log =
      renderDf1 supportsColors log{
        log_level =
          log
          & log_level
          & Level.toDf1
        }

and provide the logWithLevel function as a log implementation to my implementation of an Amazonka effect. Amazonka's monad is ResourceT + Reader (Amazonka.Env), where Amazonka.Env contains a Logger :: LogLevel -> ByteStringBuilder -> IO () that gets called to do the actual logging:

data Aws' withAuth :: Effect where
  SendEither ::
    (AWSRequest a, Typeable a, Typeable (AWSResponse a)) =>
    a
    -> Aws' Identity m (Either Amazonka.Error (AWSResponse a))
  AwaitEither ::
    (AWSRequest a, Typeable a) =>
    Amazonka.Wait a
    -> a
    -> Aws' Identity m (Either Amazonka.Error Amazonka.Accept)
  -- TODO: paginateEither
  SendUnsignedEither ::
    (AWSRequest a, Typeable a, Typeable (AWSResponse a)) =>
    a
    -> Aws' withAuth m (Either Amazonka.Error (AWSResponse a))
  LocalEnv' ::
    (Amazonka.Env' withAuth -> Amazonka.Env' withAuth)
    -> m a
    -> Aws' withAuth m a

type Aws = Aws' Identity
type AwsNoAuth = Aws' Proxy

run ::
  forall withAuth a es.
  (IOE :> es, Resource :> es) =>
  Amazonka.Env' withAuth
  -> Eff (Aws' withAuth : es) a
  -> Eff es a
run awsEnv = reinterpret (runReader awsEnv) $ \env -> \case
  SendEither req -> adapt @withAuth (\env -> Amazonka.sendEither env req)
  AwaitEither waiter req -> adapt @withAuth (\env -> Amazonka.awaitEither env waiter req)
  SendUnsignedEither req -> adapt @withAuth (\env -> Amazonka.sendUnsignedEither env req)
  LocalEnv' f action -> do
    unliftStrat <- Effectful.unliftStrategy
    Reader.local @(Amazonka.Env' withAuth)
      f
      (localUnlift env unliftStrat $ \unlift -> unlift action)
 where
  adapt ::
    forall withAuth' a' es'.
    (Reader (Amazonka.Env' withAuth') :> es') =>
    (Amazonka.Env' withAuth' -> Eff es' a')
    -> Eff es' a'
  adapt envToAction = do
    env <- Reader.ask @(Amazonka.Env' withAuth')
    envToAction env

I have been able to write the following function to try and inject Log as a Logger, and it type checks. However, running it results in a hang (infinite recursion?) when Amazonka actually tries to use the injected Logger:

withLogs ::
  forall withAuth a es.
  ( IOE :> es
  , HasCallStack
  , Log :> es
  , Aws' withAuth :> es
  ) =>
  Eff es a
  -> Eff es a
withLogs = Dynamic.interpose @(Aws' withAuth) $ \env awsOp -> do
  unliftStrat <- Effectful.unliftStrategy
  awsLogger <- localLend @Log env unliftStrat $ \useLog -> localUnliftIO env unliftStrat $ \intoIO -> do
    pure
      ( ( \awsLevel binBuilder -> do
            intoIO $
              useLog $
                Log.logWithLevel
                  (convertLogLevel awsLevel)
                  (toLogMessage binBuilder)
        ) :: Amazonka.Logger
      )
  localEnv' @withAuth (#logger .~ awsLogger) $ localUnlift env unliftStrat $ \unlift -> unlift $ Dynamic.send awsOp
 where
  convertLogLevel :: Amazonka.LogLevel -> Log.Level
  convertLogLevel = ...

  toLogMessage :: Lazy.BinaryBuilder -> Log.Message
  toLogMessage = ...

Full (of wip nonsense) `Effect/Amazonka.hs`:

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE OverloadedLabels #-}
{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}

{-# HLINT ignore "Avoid lambda using `infix`" #-}
module Yf.Effect.Amazonka (
  -- Effect types
  Aws',
  Aws,
  AwsNoAuth,
  -- Runners
  run,
  withLogs,
  runDiscover,
  run,
  -- Effects
  sendEither,
  sendUnsignedEither,
  awaitEither,
) where

import Prelude hiding (Reader, error, filter, runReader)

import Data.Binary.Builder qualified as BinaryBuilder
import Data.Text.Encoding.Error qualified as TextEncodeError
import Data.Text.Lazy.Encoding qualified as TLE
import Effectful (
  DispatchOf,
  Eff,
  Effect,
  IOE,
  Limit (Unlimited),
  Persistence (Persistent),
  UnliftStrategy (ConcUnlift),
  inject,
  (:>),
 )
import Effectful qualified as Effectful
import Effectful.Dispatch.Dynamic (
  interpret,
  localLend,
  localLiftUnliftIO,
  localSeqUnlift,
  localUnlift,
  localUnliftIO,
  reinterpret,
 )
import Effectful.Dispatch.Dynamic qualified as Dynamic
import Effectful.Reader.Dynamic (Reader (), runReader)
import Effectful.Reader.Dynamic as Reader
import Effectful.Resource (Resource)
import Effectful.Resource qualified as Resource
import Effectful.TH (makeEffect)
import Optics
import Yf.Effect.Log (Log)
import Yf.Effect.Log qualified as Log

import Amazonka (AWSRequest, AWSResponse)
import Amazonka qualified as Amazonka

import Effectful.Dispatch.Static (SideEffects (NoSideEffects))
import Type.Reflection (Typeable)

import GHC.Stack (callStack, prettyCallStack)

data Aws' withAuth :: Effect where
  SendEither ::
    (AWSRequest a, Typeable a, Typeable (AWSResponse a)) =>
    a
    -> Aws' Identity m (Either Amazonka.Error (AWSResponse a))
  AwaitEither ::
    (AWSRequest a, Typeable a) =>
    Amazonka.Wait a
    -> a
    -> Aws' Identity m (Either Amazonka.Error Amazonka.Accept)
  -- TODO: paginateEither
  SendUnsignedEither ::
    (AWSRequest a, Typeable a, Typeable (AWSResponse a)) =>
    a
    -> Aws' withAuth m (Either Amazonka.Error (AWSResponse a))
  LocalEnv' ::
    (Amazonka.Env' withAuth -> Amazonka.Env' withAuth)
    -> m a
    -> Aws' withAuth m a

type Aws = Aws' Identity
type AwsNoAuth = Aws' Proxy

type instance DispatchOf (Aws' withAuth) = Effectful.Dynamic

localEnv' ::
  forall withAuth a es.
  (Aws' withAuth :> es) =>
  (Amazonka.Env' withAuth -> Amazonka.Env' withAuth)
  -> Eff es a
  -> Eff es a
localEnv' f action = Dynamic.send (LocalEnv' f action)

-- localEnv' f action = send (LocalEnv' f action)
--
-- localEnv ::
--  forall newAuth currentAuth a es.
--  (Amazonka.Env' currentAuth -> Amazonka.Env' newAuth)
--  -> Eff (Aws' newAuth : es) a
--  -> Eff (Aws' currentAuth : es) a
-- localEnv f a = localEnv' f (rewrite a)
--  where
--    rewrite :: Eff (Aws' newAuth : es) -> Eff (Aws' currentAuth : es) (Eff '[Aws' newAuth] a)
--    rewrite =

sendEither ::
  (HasCallStack, Aws :> es, AWSRequest a, Typeable a, Typeable (AWSResponse a)) =>
  a
  -> Eff es (Either Amazonka.Error (AWSResponse a))
sendEither req = Dynamic.send (SendEither req)

awaitEither ::
  (HasCallStack, Aws :> es, AWSRequest a, Typeable a) =>
  Amazonka.Wait a
  -> a
  -> Eff es (Either Amazonka.Error Amazonka.Accept)
awaitEither wait req = Dynamic.send (AwaitEither wait req)

sendUnsignedEither ::
  forall withAuth a es.
  (HasCallStack, Aws' withAuth :> es, AWSRequest a, Typeable a, Typeable (AWSResponse a)) =>
  a
  -> Eff es (Either Amazonka.Error (AWSResponse a))
sendUnsignedEither req = Dynamic.send (SendUnsignedEither @a @withAuth req)

run ::
  forall withAuth a es.
  (IOE :> es, Resource :> es) =>
  Amazonka.Env' withAuth
  -> Eff (Aws' withAuth : es) a
  -> Eff es a
run awsEnv = reinterpret (runReader awsEnv) $ \env -> \case
  SendEither req -> adapt @withAuth (\env -> Amazonka.sendEither env req)
  AwaitEither waiter req -> adapt @withAuth (\env -> Amazonka.awaitEither env waiter req)
  SendUnsignedEither req -> adapt @withAuth (\env -> Amazonka.sendUnsignedEither env req)
  LocalEnv' f action -> do
    unliftStrat <- Effectful.unliftStrategy
    Reader.local @(Amazonka.Env' withAuth)
      f
      (localUnlift env unliftStrat $ \unlift -> unlift action)
 where
  adapt ::
    forall withAuth' a' es'.
    (Reader (Amazonka.Env' withAuth') :> es') =>
    (Amazonka.Env' withAuth' -> Eff es' a')
    -> Eff es' a'
  adapt envToAction = do
    env <- Reader.ask @(Amazonka.Env' withAuth')
    envToAction env

withLogs ::
  forall withAuth a es.
  ( IOE :> es
  , HasCallStack
  , Log :> es
  , Aws' withAuth :> es
  ) =>
  Eff es a
  -> Eff es a
withLogs = Dynamic.interpose @(Aws' withAuth) $ \env awsOp -> do
  -- Log.push "(amazonka)" $ do
  -- logFn <- Log.askLogFn
  -- putStrLn $ prettyCallStack $ callStack
  unliftStrat <- Effectful.unliftStrategy
  -- localLend env unliftStrat $ \lendLog ->  $ \intoIO -> lendLog $ do
  -- intoIO $ Log.push "(amazonka)"
  awsLogger <- localLend @Log env unliftStrat $ \useLog -> localUnliftIO env unliftStrat $ \intoIO -> do
    pure
      ( ( \awsLevel binBuilder -> do
            intoIO $
              useLog $
                Log.logWithLevel
                  (convertLogLevel awsLevel)
                  ( BinaryBuilder.toLazyByteString binBuilder
                      & TLE.decodeUtf8With TextEncodeError.lenientDecode
                      & Log.message
                  )
        ) ::
          Amazonka.Logger
      )
  localEnv' @withAuth (#logger .~ awsLogger) $ localUnlift env unliftStrat $ \unlift -> unlift $ Dynamic.send awsOp
 where
  convertLogLevel :: Amazonka.LogLevel -> Log.Level
  convertLogLevel = \case
    Amazonka.Error -> Log.Error Log.Rate
    Amazonka.Info -> Log.Info
    Amazonka.Debug -> Log.Debug
    Amazonka.Trace -> Log.TraceSensitive

runDiscover ::
  (IOE :> es, Log :> es, Resource :> es) =>
  Eff (Aws : es) a
  -> Eff es a
runDiscover action = do
  env <- Amazonka.newEnv Amazonka.discover
  action
    & withLogs @Identity
    & run env

My current suspicion is that the send at the end results in the effect getting sent back to the withLogs handler via the unlift, but I don't know how to get around this. I've tried a bunch of other permeutations that type checked, but they've all had the same problem. Any help getting me pointed in the right direction would be greatly appreciated!

Notes:

• Using withLogs only hangs if the log messages get forced. If I filter out every log message, everything works as expected.
• Profile of a trivial program hitting this hang condition:

(expand)

   1   │     Fri Sep 27 22:38 2024 Time and Allocation Profiling Report  (Final)
   2   │
   3   │        discordbot-exe +RTS -N -p -RTS --trace-sensitive
   4   │
   5   │     total time  =        0.85 secs   (3142 ticks @ 1000 us, 8 processors)
   6   │     total alloc = 3,402,386,456 bytes  (excludes profiling overheads)
   7   │
   8   │ COST CENTRE           MODULE                     SRC                                                 %time %alloc
   9   │
  10   │ unsafeEff             Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:154:1-29             16.5    7.6
  11   │ getLocation           Effectful.Internal.Env     src/Effectful/Internal/Env.hs:(348,1)-(360,16)        8.1    7.9
  12   │ primitive             Control.Monad.Primitive    Control/Monad/Primitive.hs:100:3-16                   7.7    1.7
  13   │ >>=.\.\               Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:260:51-64             7.4   10.8
  14   │ getEnv                Effectful.Internal.Env     src/Effectful/Internal/Env.hs:(306,1)-(308,33)        5.6    4.6
  15   │ send.\                Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:(531,30)-(537,64)     4.8    3.7
  16   │ seqUnlift             Effectful.Internal.Unlift  src/Effectful/Internal/Unlift.hs:(99,1)-(107,77)      3.4    8.3
  17   │ unEff                 Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:147:1-21              3.4    0.0
  18   │ >>=.\                 Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:260:36-64             3.0    0.0
  19   │ stateEnv              Effectful.Internal.Env     src/Effectful/Internal/Env.hs:(326,1)-(330,8)         2.5    2.0
  20   │ localStaticRep.\      Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:(627,41)-(631,22)     2.2    2.2
  21   │ >>=                   Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:260:3-64              2.1    4.0
  22   │ copyRef               Effectful.Dispatch.Dynamic src/Effectful/Dispatch/Dynamic.hs:(856,1)-(865,27)    1.9    3.5
  23   │ reinterpret.mkHandler Effectful.Dispatch.Dynamic src/Effectful/Dispatch/Dynamic.hs:436:5-84            1.6    2.3
  24   │ gfieldImpl            Optics.Internal.Generic    src/Optics/Internal/Generic.hs:116:3-77               1.5    1.0
  25   │ gfieldImpl.\          Optics.Internal.Generic    src/Optics/Internal/Generic.hs:116:45-76              1.4    4.1
  26   │ unsafeEff_            Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:161:1-34              1.3    1.2
  27   │ seqUnliftIO           Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:230:1-39              1.3    2.5
  28   │ withLogs.\.\          Yf.Effect.Amazonka         src/Yf/Effect/Amazonka.hs:188:89-115                  1.3    1.0
  29   │ withLogs              Yf.Effect.Amazonka         src/Yf/Effect/Amazonka.hs:(165,1)-(197,40)            1.2    4.2
  30   │ seqUnlift.\           Effectful.Internal.Unlift  src/Effectful/Internal/Unlift.hs:(101,13)-(107,77)    1.2    0.6
  31   │ withLogs.\.\          Yf.Effect.Amazonka         src/Yf/Effect/Amazonka.hs:(172,60)-(186,7)            1.2    1.9
  32   │ gsetFieldProd         Optics.Internal.Generic    src/Optics/Internal/Generic.hs:160:3-59               1.1    0.7
  33   │ getLocation.version   Effectful.Internal.Env     src/Effectful/Internal/Env.hs:351:7-43                1.0    0.0
  34   │ to                    Amazonka.Env               src/Amazonka/Env.hs:81:19-25                          0.9    1.8
  35   │ send                  Effectful.Internal.Monad   src/Effectful/Internal/Monad.hs:(531,1)-(537,64)      0.9    1.2
  36   │ first'                Data.Profunctor.Indexed    src/Data/Profunctor/Indexed.hs:293:3-57               0.7    1.3
  37   │ run.\.\.\             Yf.Effect.Amazonka         src/Yf/Effect/Amazonka.hs:145:49-61                   0.6    1.0
  38   │ indexByteArray#       Data.Primitive.Types       Data/Primitive/Types.hs:276:220-285                   0.6    2.9
  39   │ dimap                 Data.Profunctor.Indexed    src/Data/Profunctor/Indexed.hs:192:3-47               0.6    1.5
  40   │ run                   Yf.Effect.Amazonka         src/Yf/Effect/Amazonka.hs:(137,1)-(154,19)            0.6    3.0
  41   │ readByteArray#        Data.Primitive.Types       Data/Primitive/Types.hs:276:305-438                   0.2    1.4

[arybczak]

Unrelated, but using unliftStrategy from IOE for local unlifts is incorrect. The type of unlift only depends locally on the functions you're unlifting. Well, ok, not quite if you use the unlifting function out of its scope like in withLogs because who knows where it's going to end up being called, but then if SeqUnlift doesn't work, you can just use ConcUnlift for it. You can definitely use localSeqUnlift for unlifting local in LocalEnv'.

My current suspicion is that the send at the end results in the effect getting sent back to the withLogs handler via the unlift

This is correct. By sending in the local environment you're sending to the newest handler, which is most likely the one you're currently defining, so it'll just loop.

The last line should be localEnv' @withAuth (#logger .~ awsLogger) $ Dynamic.send awsOp. That doesn't type check if you don't pattern match on the awsOp though (if Aws' had m as a phantom type parameter you could do Dynamic.send (Data.Coerce.coerce awsOp), but it doesn't), so you need to do that.

Though I don't see why you need the withLogs function to be an interpose. Looks like you just need to inject the logger via localEnv', i.e.:

withLogs ::
  forall withAuth a es.
  ( IOE :> es
  , HasCallStack
  , Log :> es
  , Aws' withAuth :> es
  ) =>
  Eff es a
  -> Eff es a
withLogs action = do
  awsLogger <- withSeqEffToIO $ \intoIO -> do
    pure
      ( ( \awsLevel binBuilder -> do
            intoIO $
              useLog $
                Log.logWithLevel
                  (convertLogLevel awsLevel)
                  (toLogMessage binBuilder)
        ) :: Amazonka.Logger
      )
  localEnv' @withAuth (#logger .~ awsLogger) action
 where
  convertLogLevel :: Amazonka.LogLevel -> Log.Level
  convertLogLevel = ...

  toLogMessage :: Lazy.BinaryBuilder -> Log.Message
  toLogMessage = ...

[arybczak]

FWIW, you can also use log-effectful package for logging. The library log-base it wraps already has a convenient logMessageIO function that's precisely for this use-case - passing a logger to external libraries such as amazonka.

[YourFin]

Oh, thank you! I totally missed with(?Seq)EffectToIO. That was very much the root of my problem.

Though I don't see why you need the withLogs function to be an interpose

Without withEffectToIO, unlift and friends are the only way to do ((Eff -> IO) -> IO) -> Eff, and they need an env. interpose was the only way to grab one here.

The last line should be localEnv' @withAuth (#logger .~ awsLogger) $ Dynamic.send awsOp. That doesn't type check if you don't pattern match on the awsOp though (if Aws' had m as a phantom type parameter you could do Dynamic.send (Data.Coerce.coerce awsOp), but it doesn't), so you need to do that.

Ah, that explains a ton. Thanks for the explanation! I don't think I would have figured that one out for a looong time.

[YourFin]

FWIW, you can also use log-effectful package for logging. The library log-base it wraps already has a convenient logMessageIO function that's precisely for this use-case - passing a logger to external libraries such as amazonka.

I have some odd things I want to try with logging that will require a bespoke effect and handler, but the pointer is appreciated!

[arybczak]

Ah, that explains a ton. Thanks for the explanation! I don't think I would have figured that one out for a looong time.

Yes, it's quite non-obvious. I added this explanation to the documentation of interpose in 89b5791 so hopefully it confuses less people in the future 🙂