diff --git a/components/amazonka/Effectful/Zoo/Amazonka/Api/Run.hs b/components/amazonka/Effectful/Zoo/Amazonka/Api/Run.hs
--- a/components/amazonka/Effectful/Zoo/Amazonka/Api/Run.hs
+++ b/components/amazonka/Effectful/Zoo/Amazonka/Api/Run.hs
@@ -22,7 +22,7 @@
 import Effectful.Zoo.Core
 import Effectful.Zoo.DataLog.Api
 import Effectful.Zoo.DataLog.Data.LogEntry
-import Effectful.Zoo.DataLog.Dynamic
+import Effectful.Zoo.DataLog.Static
 import Effectful.Zoo.Log.Data.LogMessage
 import Effectful.Zoo.Log.Data.Severity
 import HaskellWorks.Prelude
diff --git a/components/amazonka/Effectful/Zoo/Amazonka/Api/Send.hs b/components/amazonka/Effectful/Zoo/Amazonka/Api/Send.hs
--- a/components/amazonka/Effectful/Zoo/Amazonka/Api/Send.hs
+++ b/components/amazonka/Effectful/Zoo/Amazonka/Api/Send.hs
@@ -18,7 +18,7 @@
 import Effectful.Zoo.Amazonka.Dynamic
 import Effectful.Zoo.Core
 import Effectful.Zoo.DataLog.Api
-import Effectful.Zoo.DataLog.Dynamic
+import Effectful.Zoo.DataLog.Static
 import Effectful.Zoo.Lazy.Dynamic
 import GHC.Stack qualified as GHC
 import HaskellWorks.Prelude
diff --git a/components/amazonka/Effectful/Zoo/Amazonka/Static.hs b/components/amazonka/Effectful/Zoo/Amazonka/Static.hs
--- a/components/amazonka/Effectful/Zoo/Amazonka/Static.hs
+++ b/components/amazonka/Effectful/Zoo/Amazonka/Static.hs
@@ -20,7 +20,7 @@
 import Effectful.Zoo.Amazonka.Data
 import Effectful.Zoo.Core
 import Effectful.Zoo.DataLog.Api
-import Effectful.Zoo.DataLog.Dynamic
+import Effectful.Zoo.DataLog.Static
 import Effectful.Zoo.Lazy.Dynamic
 import GHC.Stack qualified as GHC
 import HaskellWorks.Prelude
diff --git a/components/core/Effectful/Zoo/DataLog/Api.hs b/components/core/Effectful/Zoo/DataLog/Api.hs
--- a/components/core/Effectful/Zoo/DataLog/Api.hs
+++ b/components/core/Effectful/Zoo/DataLog/Api.hs
@@ -5,63 +5,5 @@
     putJsonStdout,
   ) where
 
-import Data.Aeson (Value, object, (.=))
-import Data.Aeson qualified as J
-import Data.ByteString.Lazy qualified as LBS
-import Effectful
-import Effectful.Dispatch.Dynamic
-import Effectful.Dispatch.Static
-import Effectful.Zoo.Core
-import Effectful.Zoo.DataLog.Data.LogEntry
-import Effectful.Zoo.DataLog.Dynamic
-import Effectful.Zoo.Log.Data.LogMessage
-import GHC.Stack qualified as GHC
-import HaskellWorks.Prelude
-import System.IO qualified as IO
-
-dataLog :: forall i r. ()
-  => HasCallStack
-  => r <: DataLog i
-  => i
-  -> Eff r ()
-dataLog i =
-  withFrozenCallStack do
-    send $ DataLog i
-
-logEntryToJson :: forall a. ()
-  => (a -> Value)
-  -> LogEntry a
-  -> Value
-logEntryToJson aToJson (LogEntry value time callstack) =
-    object
-      [ "time" .= time
-      , "data" .= aToJson value
-      , "callstack" .= fmap callsiteToJson (GHC.getCallStack callstack)
-      ]
-    where
-      callsiteToJson :: ([Char], GHC.SrcLoc) -> Value
-      callsiteToJson (caller, srcLoc) =
-        object
-          [ "caller"    .= caller
-          , "package"   .= GHC.srcLocPackage srcLoc
-          , "module"    .= GHC.srcLocModule srcLoc
-          , "file"      .= GHC.srcLocFile srcLoc
-          , "startLine" .= GHC.srcLocStartLine srcLoc
-          , "startCol"  .= GHC.srcLocStartCol srcLoc
-          , "endLine"   .= GHC.srcLocEndLine srcLoc
-          , "endCol"    .= GHC.srcLocEndCol srcLoc
-          ]
-
-logMessageToJson :: LogMessage Text -> Value
-logMessageToJson (LogMessage severity message) =
-    object
-      [ "severity" .= show severity
-      , "message"  .= message
-      ]
-
-putJsonStdout :: ()
-  => Value
-  -> Eff r ()
-putJsonStdout value = do
-  unsafeEff_ $ LBS.putStr $ J.encode value <> "\n"
-  unsafeEff_ $ IO.hFlush IO.stdout
+import Effectful.Zoo.DataLog.Static
+import Effectful.Zoo.DataLog.Api.Json
diff --git a/components/core/Effectful/Zoo/DataLog/Api/Json.hs b/components/core/Effectful/Zoo/DataLog/Api/Json.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/DataLog/Api/Json.hs
@@ -0,0 +1,54 @@
+module Effectful.Zoo.DataLog.Api.Json
+  ( logEntryToJson,
+    logMessageToJson,
+    putJsonStdout,
+  ) where
+
+import Data.Aeson (Value, object, (.=))
+import Data.Aeson qualified as J
+import Data.ByteString.Lazy qualified as LBS
+import Effectful
+import Effectful.Dispatch.Static
+import Effectful.Zoo.DataLog.Data.LogEntry
+import Effectful.Zoo.Log.Data.LogMessage
+import GHC.Stack qualified as GHC
+import HaskellWorks.Prelude
+import System.IO qualified as IO
+
+logEntryToJson :: forall a. ()
+  => (a -> Value)
+  -> LogEntry a
+  -> Value
+logEntryToJson aToJson (LogEntry value time callstack) =
+    object
+      [ "time" .= time
+      , "data" .= aToJson value
+      , "callstack" .= fmap callsiteToJson (GHC.getCallStack callstack)
+      ]
+    where
+      callsiteToJson :: ([Char], GHC.SrcLoc) -> Value
+      callsiteToJson (caller, srcLoc) =
+        object
+          [ "caller"    .= caller
+          , "package"   .= GHC.srcLocPackage srcLoc
+          , "module"    .= GHC.srcLocModule srcLoc
+          , "file"      .= GHC.srcLocFile srcLoc
+          , "startLine" .= GHC.srcLocStartLine srcLoc
+          , "startCol"  .= GHC.srcLocStartCol srcLoc
+          , "endLine"   .= GHC.srcLocEndLine srcLoc
+          , "endCol"    .= GHC.srcLocEndCol srcLoc
+          ]
+
+logMessageToJson :: LogMessage Text -> Value
+logMessageToJson (LogMessage severity message) =
+    object
+      [ "severity" .= show severity
+      , "message"  .= message
+      ]
+
+putJsonStdout :: ()
+  => Value
+  -> Eff r ()
+putJsonStdout value = do
+  unsafeEff_ $ LBS.putStr $ J.encode value <> "\n"
+  unsafeEff_ $ IO.hFlush IO.stdout
diff --git a/components/core/Effectful/Zoo/DataLog/Dynamic.hs b/components/core/Effectful/Zoo/DataLog/Dynamic.hs
--- a/components/core/Effectful/Zoo/DataLog/Dynamic.hs
+++ b/components/core/Effectful/Zoo/DataLog/Dynamic.hs
@@ -1,31 +1,8 @@
 module Effectful.Zoo.DataLog.Dynamic
   ( DataLog (..),
     runDataLog,
+    dataLog,
   ) where
 
-import Effectful
-import Effectful.Dispatch.Dynamic
-import Effectful.Zoo.DataLog.Static qualified as S
-import HaskellWorks.Prelude
-
-data DataLog a :: Effect where
-  DataLog
-    :: a
-    -> DataLog a m ()
-
-  Local
-    :: (a -> a)
-    -> m b
-    -> DataLog a m b
-
-type instance DispatchOf (DataLog a) = Dynamic
-
-runDataLog :: ()
-  => HasCallStack
-  => (HasCallStack => i -> Eff r ())
-  -> Eff (DataLog i : r) a
-  -> Eff r a
-runDataLog run =
-  reinterpret (S.runDataLog run) $ \env -> \case
-    DataLog i -> S.log i
-    Local f m -> localSeqUnlift env $ \unlift -> S.local f (unlift m)
+import Effectful.Zoo.DataLog.Dynamic.Api
+import Effectful.Zoo.DataLog.Dynamic.Effect
diff --git a/components/core/Effectful/Zoo/DataLog/Dynamic/Api.hs b/components/core/Effectful/Zoo/DataLog/Dynamic/Api.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/DataLog/Dynamic/Api.hs
@@ -0,0 +1,18 @@
+module Effectful.Zoo.DataLog.Dynamic.Api
+  ( dataLog,
+  ) where
+
+import Effectful
+import Effectful.Dispatch.Dynamic
+import Effectful.Zoo.Core
+import Effectful.Zoo.DataLog.Dynamic.Effect
+import HaskellWorks.Prelude
+
+dataLog :: forall i r. ()
+  => HasCallStack
+  => r <: DataLog i
+  => i
+  -> Eff r ()
+dataLog i =
+  withFrozenCallStack do
+    send $ DataLog i
diff --git a/components/core/Effectful/Zoo/DataLog/Dynamic/Effect.hs b/components/core/Effectful/Zoo/DataLog/Dynamic/Effect.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/DataLog/Dynamic/Effect.hs
@@ -0,0 +1,31 @@
+module Effectful.Zoo.DataLog.Dynamic.Effect
+  ( DataLog (..),
+    runDataLog,
+  ) where
+
+import Effectful
+import Effectful.Dispatch.Dynamic
+import Effectful.Zoo.DataLog.Static qualified as S
+import HaskellWorks.Prelude
+
+data DataLog a :: Effect where
+  DataLog
+    :: a
+    -> DataLog a m ()
+
+  Local
+    :: (a -> a)
+    -> m b
+    -> DataLog a m b
+
+type instance DispatchOf (DataLog a) = Dynamic
+
+runDataLog :: ()
+  => HasCallStack
+  => (HasCallStack => i -> Eff r ())
+  -> Eff (DataLog i : r) a
+  -> Eff r a
+runDataLog run =
+  reinterpret (S.runDataLog run) $ \env -> \case
+    DataLog i -> S.dataLog i
+    Local f m -> localSeqUnlift env $ \unlift -> S.localDataLog f (unlift m)
diff --git a/components/core/Effectful/Zoo/DataLog/Static.hs b/components/core/Effectful/Zoo/DataLog/Static.hs
--- a/components/core/Effectful/Zoo/DataLog/Static.hs
+++ b/components/core/Effectful/Zoo/DataLog/Static.hs
@@ -4,97 +4,11 @@
     runDataLogTextToHandle,
     runDataLogTextToStdout,
     runDataLogTextToStderr,
+    getDataLogger,
     withDataLog,
-    log,
-    local,
+    dataLog,
+    localDataLog,
   ) where
 
-import Data.Text.IO qualified as T
-import Data.Kind
-import Effectful
-import Effectful.Zoo.Core
-import Effectful.Dispatch.Static
-import Effectful.Zoo.DataLog.Data.DataLogger
-import HaskellWorks.Prelude
-import System.IO qualified as IO
-
-data DataLog (i :: Type) :: Effect
-
-type instance DispatchOf (DataLog i) = Static NoSideEffects
-
-newtype instance StaticRep (DataLog i) = DataLog (DataLogger i)
-
-runDataLog :: forall i a r. ()
-  => HasCallStack
-  => (HasCallStack => i -> Eff r ())
-  -> Eff (DataLog i : r) a
-  -> Eff r a
-runDataLog run f = do
-  s <- mkDataLogger run
-  evalStaticRep (DataLog s) f
-
-runDataLogTextToHandle :: ()
-  => HasCallStack
-  => Handle
-  -> Eff (DataLog Text : r) a
-  -> Eff r a
-runDataLogTextToHandle h =
-  evalStaticRep $ DataLog $ DataLogger $ T.hPutStrLn h
-
-runDataLogTextToStdout :: ()
-  => HasCallStack
-  => Eff (DataLog Text : r) a
-  -> Eff r a
-runDataLogTextToStdout =
-  runDataLogTextToHandle IO.stdout
-
-runDataLogTextToStderr :: ()
-  => HasCallStack
-  => Eff (DataLog Text : r) a
-  -> Eff r a
-runDataLogTextToStderr =
-  runDataLogTextToHandle IO.stderr
-
-withDataLogSerialiser :: ()
-  => HasCallStack
-  => (DataLogger i -> DataLogger o)
-  -> Eff (DataLog o : r) a
-  -> Eff (DataLog i : r) a
-withDataLogSerialiser f m = do
-  logger <- getDataLogger
-  let _ = logger
-  raise $ evalStaticRep (DataLog (f logger)) m
-
-withDataLog :: ()
-  => HasCallStack
-  => (o -> i)
-  -> Eff (DataLog o : r) a
-  -> Eff (DataLog i : r) a
-withDataLog =
-  withDataLogSerialiser . contramap
-
-getDataLogger :: ()
-  => HasCallStack
-  => r <: DataLog i
-  => Eff r (DataLogger i)
-getDataLogger = do
-  DataLog i <- getStaticRep
-  pure i
-
-log :: ()
-  => HasCallStack
-  => r <: DataLog i
-  => i
-  -> Eff r ()
-log i = do
-  dataLogger <- getDataLogger
-  unsafeEff_ $ dataLogger.run i
-
-local :: ()
-  => HasCallStack
-  => r <: DataLog i
-  => (i -> i)
-  -> Eff r a
-  -> Eff r a
-local f =
-  localStaticRep $ \(DataLog s) -> DataLog (contramap f s)
+import Effectful.Zoo.DataLog.Static.Api
+import Effectful.Zoo.DataLog.Static.Effect
diff --git a/components/core/Effectful/Zoo/DataLog/Static/Api.hs b/components/core/Effectful/Zoo/DataLog/Static/Api.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/DataLog/Static/Api.hs
@@ -0,0 +1,19 @@
+module Effectful.Zoo.DataLog.Static.Api
+  ( dataLog,
+  ) where
+
+import Effectful
+import Effectful.Dispatch.Static
+import Effectful.Zoo.Core
+import Effectful.Zoo.DataLog.Data.DataLogger
+import Effectful.Zoo.DataLog.Static.Effect
+import HaskellWorks.Prelude
+
+dataLog :: forall i r. ()
+  => HasCallStack
+  => r <: DataLog i
+  => i
+  -> Eff r ()
+dataLog i = do
+  dataLogger <- getDataLogger
+  unsafeEff_ $ dataLogger.run i
diff --git a/components/core/Effectful/Zoo/DataLog/Static/Effect.hs b/components/core/Effectful/Zoo/DataLog/Static/Effect.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/DataLog/Static/Effect.hs
@@ -0,0 +1,91 @@
+module Effectful.Zoo.DataLog.Static.Effect
+  ( DataLog,
+    runDataLog,
+    runDataLogTextToHandle,
+    runDataLogTextToStdout,
+    runDataLogTextToStderr,
+    getDataLogger,
+    withDataLog,
+    localDataLog,
+  ) where
+
+import Data.Text.IO qualified as T
+import Data.Kind
+import Effectful
+import Effectful.Zoo.Core
+import Effectful.Dispatch.Static
+import Effectful.Zoo.DataLog.Data.DataLogger
+import HaskellWorks.Prelude
+import System.IO qualified as IO
+
+data DataLog (i :: Type) :: Effect
+
+type instance DispatchOf (DataLog i) = Static NoSideEffects
+
+newtype instance StaticRep (DataLog i) = DataLog (DataLogger i)
+
+runDataLog :: forall i a r. ()
+  => HasCallStack
+  => (HasCallStack => i -> Eff r ())
+  -> Eff (DataLog i : r) a
+  -> Eff r a
+runDataLog run f = do
+  s <- mkDataLogger run
+  evalStaticRep (DataLog s) f
+
+runDataLogTextToHandle :: ()
+  => HasCallStack
+  => Handle
+  -> Eff (DataLog Text : r) a
+  -> Eff r a
+runDataLogTextToHandle h =
+  evalStaticRep $ DataLog $ DataLogger $ T.hPutStrLn h
+
+runDataLogTextToStdout :: ()
+  => HasCallStack
+  => Eff (DataLog Text : r) a
+  -> Eff r a
+runDataLogTextToStdout =
+  runDataLogTextToHandle IO.stdout
+
+runDataLogTextToStderr :: ()
+  => HasCallStack
+  => Eff (DataLog Text : r) a
+  -> Eff r a
+runDataLogTextToStderr =
+  runDataLogTextToHandle IO.stderr
+
+withDataLogSerialiser :: ()
+  => HasCallStack
+  => (DataLogger i -> DataLogger o)
+  -> Eff (DataLog o : r) a
+  -> Eff (DataLog i : r) a
+withDataLogSerialiser f m = do
+  logger <- getDataLogger
+  let _ = logger
+  raise $ evalStaticRep (DataLog (f logger)) m
+
+withDataLog :: ()
+  => HasCallStack
+  => (o -> i)
+  -> Eff (DataLog o : r) a
+  -> Eff (DataLog i : r) a
+withDataLog =
+  withDataLogSerialiser . contramap
+
+getDataLogger :: ()
+  => HasCallStack
+  => r <: DataLog i
+  => Eff r (DataLogger i)
+getDataLogger = do
+  DataLog i <- getStaticRep
+  pure i
+
+localDataLog :: ()
+  => HasCallStack
+  => r <: DataLog i
+  => (i -> i)
+  -> Eff r a
+  -> Eff r a
+localDataLog f =
+  localStaticRep $ \(DataLog s) -> DataLog (contramap f s)
diff --git a/components/core/Effectful/Zoo/FileSystem.hs b/components/core/Effectful/Zoo/FileSystem.hs
--- a/components/core/Effectful/Zoo/FileSystem.hs
+++ b/components/core/Effectful/Zoo/FileSystem.hs
@@ -33,8 +33,7 @@
 import Effectful.Zoo.Core
 import Effectful.Zoo.Error.Static
 import Effectful.Zoo.Exception
-import Effectful.Zoo.Log.Api.Text
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import Effectful.Zoo.Unsafe
 import HaskellWorks.Error.Types.JsonDecodeError
 import HaskellWorks.Error.Types.YamlDecodeError
diff --git a/components/core/Effectful/Zoo/Log/Api.hs b/components/core/Effectful/Zoo/Log/Api.hs
--- a/components/core/Effectful/Zoo/Log/Api.hs
+++ b/components/core/Effectful/Zoo/Log/Api.hs
@@ -10,4 +10,4 @@
   ) where
 
 import Effectful.Zoo.Log.Api.Render
-import Effectful.Zoo.Log.Api.Text
+import Effectful.Zoo.Log.Static.Api
diff --git a/components/core/Effectful/Zoo/Log/Api/Generic.hs b/components/core/Effectful/Zoo/Log/Api/Generic.hs
deleted file mode 100644
--- a/components/core/Effectful/Zoo/Log/Api/Generic.hs
+++ /dev/null
@@ -1,81 +0,0 @@
-module Effectful.Zoo.Log.Api.Generic
-  ( log,
-    trace,
-    debug,
-    info,
-    warn,
-    error,
-    crit,
-  ) where
-
-import Effectful
-import Effectful.Dispatch.Dynamic
-import Effectful.Zoo.Core
-import Effectful.Zoo.Log.Data.LogMessage
-import Effectful.Zoo.Log.Data.Severity
-import Effectful.Zoo.Log.Dynamic
-import HaskellWorks.Prelude
-
-log :: ()
-  => HasCallStack
-  => r <: Log i
-  => Severity
-  -> i
-  -> Eff r ()
-log severity message =
-  withFrozenCallStack $
-    send (Log (LogMessage severity message))
-
-trace :: ()
-  => HasCallStack
-  => r <: Log i
-  => i
-  -> Eff r ()
-trace =
-  withFrozenCallStack $
-    log Trace
-
-debug :: ()
-  => HasCallStack
-  => r <: Log i
-  => i
-  -> Eff r ()
-debug =
-  withFrozenCallStack $
-    log Debug
-
-info :: ()
-  => HasCallStack
-  => r <: Log i
-  => i
-  -> Eff r ()
-info =
-  withFrozenCallStack $
-    log Info
-
-warn :: ()
-  => HasCallStack
-  => r <: Log i
-  => i
-  -> Eff r ()
-warn =
-  withFrozenCallStack $
-    log Warn
-
-error :: ()
-  => HasCallStack
-  => r <: Log i
-  => i
-  -> Eff r ()
-error =
-  withFrozenCallStack $
-    log Error
-
-crit :: ()
-  => HasCallStack
-  => r <: Log i
-  => i
-  -> Eff r ()
-crit =
-  withFrozenCallStack $
-    log Crit
diff --git a/components/core/Effectful/Zoo/Log/Api/LazyText.hs b/components/core/Effectful/Zoo/Log/Api/LazyText.hs
deleted file mode 100644
--- a/components/core/Effectful/Zoo/Log/Api/LazyText.hs
+++ /dev/null
@@ -1,81 +0,0 @@
-module Effectful.Zoo.Log.Api.LazyText
-  ( log,
-    trace,
-    debug,
-    info,
-    warn,
-    error,
-    crit,
-  ) where
-
-import Effectful
-import Effectful.Dispatch.Dynamic
-import Effectful.Zoo.Core
-import Effectful.Zoo.Log.Data.LogMessage
-import Effectful.Zoo.Log.Data.Severity
-import Effectful.Zoo.Log.Dynamic
-import HaskellWorks.Prelude
-
-log :: ()
-  => HasCallStack
-  => r <: Log LazyText
-  => Severity
-  -> LazyText
-  -> Eff r ()
-log severity message =
-  withFrozenCallStack $
-    send (Log (LogMessage severity message))
-
-trace :: ()
-  => HasCallStack
-  => r <: Log LazyText
-  => LazyText
-  -> Eff r ()
-trace =
-  withFrozenCallStack $
-    log Trace
-
-debug :: ()
-  => HasCallStack
-  => r <: Log LazyText
-  => LazyText
-  -> Eff r ()
-debug =
-  withFrozenCallStack $
-    log Debug
-
-info :: ()
-  => HasCallStack
-  => r <: Log LazyText
-  => LazyText
-  -> Eff r ()
-info =
-  withFrozenCallStack $
-    log Info
-
-warn :: ()
-  => HasCallStack
-  => r <: Log LazyText
-  => LazyText
-  -> Eff r ()
-warn =
-  withFrozenCallStack $
-    log Warn
-
-error :: ()
-  => HasCallStack
-  => r <: Log LazyText
-  => LazyText
-  -> Eff r ()
-error =
-  withFrozenCallStack $
-    log Error
-
-crit :: ()
-  => HasCallStack
-  => r <: Log LazyText
-  => LazyText
-  -> Eff r ()
-crit =
-  withFrozenCallStack $
-    log Crit
diff --git a/components/core/Effectful/Zoo/Log/Api/String.hs b/components/core/Effectful/Zoo/Log/Api/String.hs
deleted file mode 100644
--- a/components/core/Effectful/Zoo/Log/Api/String.hs
+++ /dev/null
@@ -1,81 +0,0 @@
-module Effectful.Zoo.Log.Api.String
-  ( log,
-    trace,
-    debug,
-    info,
-    warn,
-    error,
-    crit,
-  ) where
-
-import Effectful
-import Effectful.Dispatch.Dynamic
-import Effectful.Zoo.Core
-import Effectful.Zoo.Log.Data.LogMessage
-import Effectful.Zoo.Log.Data.Severity
-import Effectful.Zoo.Log.Dynamic
-import HaskellWorks.Prelude
-
-log :: ()
-  => HasCallStack
-  => r <: Log String
-  => Severity
-  -> String
-  -> Eff r ()
-log severity message =
-  withFrozenCallStack $
-    send (Log (LogMessage severity message))
-
-trace :: ()
-  => HasCallStack
-  => r <: Log String
-  => String
-  -> Eff r ()
-trace =
-  withFrozenCallStack $
-    log Trace
-
-debug :: ()
-  => HasCallStack
-  => r <: Log String
-  => String
-  -> Eff r ()
-debug =
-  withFrozenCallStack $
-    log Debug
-
-info :: ()
-  => HasCallStack
-  => r <: Log String
-  => String
-  -> Eff r ()
-info =
-  withFrozenCallStack $
-    log Info
-
-warn :: ()
-  => HasCallStack
-  => r <: Log String
-  => String
-  -> Eff r ()
-warn =
-  withFrozenCallStack $
-    log Warn
-
-error :: ()
-  => HasCallStack
-  => r <: Log String
-  => String
-  -> Eff r ()
-error =
-  withFrozenCallStack $
-    log Error
-
-crit :: ()
-  => HasCallStack
-  => r <: Log String
-  => String
-  -> Eff r ()
-crit =
-  withFrozenCallStack $
-    log Crit
diff --git a/components/core/Effectful/Zoo/Log/Api/Text.hs b/components/core/Effectful/Zoo/Log/Api/Text.hs
deleted file mode 100644
--- a/components/core/Effectful/Zoo/Log/Api/Text.hs
+++ /dev/null
@@ -1,81 +0,0 @@
-module Effectful.Zoo.Log.Api.Text
-  ( log,
-    trace,
-    debug,
-    info,
-    warn,
-    error,
-    crit,
-  ) where
-
-import Effectful
-import Effectful.Dispatch.Dynamic
-import Effectful.Zoo.Core
-import Effectful.Zoo.Log.Data.Severity
-import Effectful.Zoo.Log.Data.LogMessage
-import Effectful.Zoo.Log.Dynamic
-import HaskellWorks.Prelude
-
-log :: ()
-  => HasCallStack
-  => r <: Log Text
-  => Severity
-  -> Text
-  -> Eff r ()
-log severity message =
-  withFrozenCallStack $
-    send (Log (LogMessage severity message))
-
-trace :: ()
-  => HasCallStack
-  => r <: Log Text
-  => Text
-  -> Eff r ()
-trace =
-  withFrozenCallStack $
-    log Trace
-
-debug :: ()
-  => HasCallStack
-  => r <: Log Text
-  => Text
-  -> Eff r ()
-debug =
-  withFrozenCallStack $
-    log Debug
-
-info :: ()
-  => HasCallStack
-  => r <: Log Text
-  => Text
-  -> Eff r ()
-info =
-  withFrozenCallStack $
-    log Info
-
-warn :: ()
-  => HasCallStack
-  => r <: Log Text
-  => Text
-  -> Eff r ()
-warn =
-  withFrozenCallStack $
-    log Warn
-
-error :: ()
-  => HasCallStack
-  => r <: Log Text
-  => Text
-  -> Eff r ()
-error =
-  withFrozenCallStack $
-    log Error
-
-crit :: ()
-  => HasCallStack
-  => r <: Log Text
-  => Text
-  -> Eff r ()
-crit =
-  withFrozenCallStack $
-    log Crit
diff --git a/components/core/Effectful/Zoo/Log/Dynamic.hs b/components/core/Effectful/Zoo/Log/Dynamic.hs
--- a/components/core/Effectful/Zoo/Log/Dynamic.hs
+++ b/components/core/Effectful/Zoo/Log/Dynamic.hs
@@ -1,35 +1,15 @@
 module Effectful.Zoo.Log.Dynamic
   ( Log (..),
     runLog,
-  ) where
 
-import Effectful
-import Effectful.Dispatch.Dynamic
-import Effectful.Zoo.Core
-import Effectful.Zoo.Log.Data.LogMessage
-import Effectful.Zoo.Log.Static qualified as S
-import HaskellWorks.Prelude
-
-data Log i :: Effect where
-  Log
-    :: HasCallStack
-    => LogMessage i
-    -> Log i m ()
-
-  Local
-    :: (i -> i)
-    -> m a
-    -> Log i m a
-
-type instance DispatchOf (Log a) = Dynamic
+    log,
+    trace,
+    debug,
+    info,
+    warn,
+    error,
+    crit,
+  ) where
 
-runLog :: forall i a r. ()
-  => r <: IOE
-  => UnliftStrategy
-  -> (CallStack -> LogMessage i -> Eff r ())
-  -> Eff (Log i : r) a
-  -> Eff r a
-runLog s run =
-  reinterpret (S.runLog s run) $ \env -> \case
-    Log m -> S.log m
-    Local f m -> localSeqUnlift env $ \unlift -> S.local f (unlift m)
+import Effectful.Zoo.Log.Dynamic.Api
+import Effectful.Zoo.Log.Dynamic.Effect
diff --git a/components/core/Effectful/Zoo/Log/Dynamic/Api.hs b/components/core/Effectful/Zoo/Log/Dynamic/Api.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/Log/Dynamic/Api.hs
@@ -0,0 +1,81 @@
+module Effectful.Zoo.Log.Dynamic.Api
+  ( log,
+    trace,
+    debug,
+    info,
+    warn,
+    error,
+    crit,
+  ) where
+
+import Effectful
+import Effectful.Dispatch.Dynamic
+import Effectful.Zoo.Core
+import Effectful.Zoo.Log.Data.LogMessage
+import Effectful.Zoo.Log.Data.Severity
+import Effectful.Zoo.Log.Dynamic.Effect
+import HaskellWorks.Prelude
+
+log :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => Severity
+  -> i
+  -> Eff r ()
+log severity message =
+  withFrozenCallStack $
+    send (Log (LogMessage severity message))
+
+trace :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+trace =
+  withFrozenCallStack $
+    log Trace
+
+debug :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+debug =
+  withFrozenCallStack $
+    log Debug
+
+info :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+info =
+  withFrozenCallStack $
+    log Info
+
+warn :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+warn =
+  withFrozenCallStack $
+    log Warn
+
+error :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+error =
+  withFrozenCallStack $
+    log Error
+
+crit :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+crit =
+  withFrozenCallStack $
+    log Crit
diff --git a/components/core/Effectful/Zoo/Log/Dynamic/Effect.hs b/components/core/Effectful/Zoo/Log/Dynamic/Effect.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/Log/Dynamic/Effect.hs
@@ -0,0 +1,35 @@
+module Effectful.Zoo.Log.Dynamic.Effect
+  ( Log (..),
+    runLog,
+  ) where
+
+import Effectful
+import Effectful.Dispatch.Dynamic
+import Effectful.Zoo.Core
+import Effectful.Zoo.Log.Data.LogMessage
+import Effectful.Zoo.Log.Static qualified as S
+import HaskellWorks.Prelude
+
+data Log i :: Effect where
+  Log
+    :: HasCallStack
+    => LogMessage i
+    -> Log i m ()
+
+  Local
+    :: (i -> i)
+    -> m a
+    -> Log i m a
+
+type instance DispatchOf (Log a) = Dynamic
+
+runLog :: forall i a r. ()
+  => r <: IOE
+  => UnliftStrategy
+  -> (CallStack -> LogMessage i -> Eff r ())
+  -> Eff (Log i : r) a
+  -> Eff r a
+runLog s run =
+  reinterpret (S.runLog s run) $ \env -> \case
+    Log m -> S.logMessage m
+    Local f m -> localSeqUnlift env $ \unlift -> S.localLog f (unlift m)
diff --git a/components/core/Effectful/Zoo/Log/Static.hs b/components/core/Effectful/Zoo/Log/Static.hs
--- a/components/core/Effectful/Zoo/Log/Static.hs
+++ b/components/core/Effectful/Zoo/Log/Static.hs
@@ -5,106 +5,18 @@
     runLogToStdout,
     runLogToStderr,
     withLog,
+    logMessage,
+    localLog,
+
     log,
-    local,
+    trace,
+    debug,
+    info,
+    warn,
+    error,
+    crit,
   ) where
 
-import Data.Kind
-import Data.Text.IO qualified as T
-import Effectful
-import Effectful.Dispatch.Static
-import Effectful.Zoo.Core
-import Effectful.Zoo.Log.Data.Logger
-import Effectful.Zoo.Log.Data.LogMessage
-import GHC.Stack qualified as GHC
-import HaskellWorks.Prelude
-import System.IO qualified as IO
-
-data Log (i :: Type) :: Effect
-
-type instance DispatchOf (Log i) = Static NoSideEffects
-
-newtype instance StaticRep (Log i) = Log (Logger i)
-
-runLog :: ()
-  => r <: IOE
-  => HasCallStack
-  => UnliftStrategy
-  -> (CallStack -> LogMessage i -> Eff r ())
-  -> Eff (Log i : r) a
-  -> Eff r a
-runLog strategy run f = do
-  s <- mkLogger strategy run
-  evalStaticRep (Log s) f
-
-runLogToHandle :: ()
-  => HasCallStack
-  => Handle
-  -> (LogMessage a -> Text)
-  -> Eff (Log a : r) a
-  -> Eff r a
-runLogToHandle h f =
-  evalStaticRep $ Log $ Logger $ \_ m ->
-    T.hPutStrLn h $ f m
-
-runLogToStdout :: ()
-  => HasCallStack
-  => (LogMessage a -> Text)
-  -> Eff (Log a : r) a
-  -> Eff r a
-runLogToStdout =
-  runLogToHandle IO.stdout
-
-runLogToStderr :: ()
-  => HasCallStack
-  => (LogMessage a -> Text)
-  -> Eff (Log a : r) a
-  -> Eff r a
-runLogToStderr =
-  runLogToHandle IO.stderr
-
-withDataLogSerialiser :: ()
-  => HasCallStack
-  => (Logger i -> Logger o)
-  -> Eff (Log o : r) a
-  -> Eff (Log i : r) a
-withDataLogSerialiser f m = do
-  logger <- getDataLogger
-  let _ = logger
-  raise $ evalStaticRep (Log (f logger)) m
-
-withLog :: ()
-  => HasCallStack
-  => (o -> i)
-  -> Eff (Log o : r) a
-  -> Eff (Log i : r) a
-withLog =
-  withDataLogSerialiser . contramap
-
-getDataLogger :: ()
-  => HasCallStack
-  => r <: Log i
-  => Eff r (Logger i)
-getDataLogger = do
-  Log i <- getStaticRep
-  pure i
-
-log :: ()
-  => HasCallStack
-  => r <: Log i
-  => r <: IOE
-  => LogMessage i
-  -> Eff r ()
-log m =
-  withFrozenCallStack do
-    dataLogger <- getDataLogger
-    liftIO $ dataLogger.run GHC.callStack m
+import Effectful.Zoo.Log.Static.Api
 
-local :: ()
-  => HasCallStack
-  => r <: Log i
-  => (i -> i)
-  -> Eff r a
-  -> Eff r a
-local f =
-  localStaticRep $ \(Log s) -> Log (contramap f s)
+import Effectful.Zoo.Log.Static.Effect
diff --git a/components/core/Effectful/Zoo/Log/Static/Api.hs b/components/core/Effectful/Zoo/Log/Static/Api.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/Log/Static/Api.hs
@@ -0,0 +1,81 @@
+module Effectful.Zoo.Log.Static.Api
+  ( log,
+    trace,
+    debug,
+    info,
+    warn,
+    error,
+    crit,
+  ) where
+
+import Effectful
+import Effectful.Dispatch.Static
+import Effectful.Zoo.Core
+import Effectful.Zoo.Log.Data.LogMessage
+import Effectful.Zoo.Log.Data.Severity
+import Effectful.Zoo.Log.Static.Effect
+import HaskellWorks.Prelude
+
+log :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => Severity
+  -> i
+  -> Eff r ()
+log severity message =
+  withFrozenCallStack $
+    logMessage $ LogMessage severity message
+
+trace :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+trace =
+  withFrozenCallStack $
+    log Trace
+
+debug :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+debug =
+  withFrozenCallStack $
+    log Debug
+
+info :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+info =
+  withFrozenCallStack $
+    log Info
+
+warn :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+warn =
+  withFrozenCallStack $
+    log Warn
+
+error :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+error =
+  withFrozenCallStack $
+    log Error
+
+crit :: forall i r. ()
+  => HasCallStack
+  => r <: Log i
+  => i
+  -> Eff r ()
+crit =
+  withFrozenCallStack $
+    log Crit
diff --git a/components/core/Effectful/Zoo/Log/Static/Effect.hs b/components/core/Effectful/Zoo/Log/Static/Effect.hs
new file mode 100644
--- /dev/null
+++ b/components/core/Effectful/Zoo/Log/Static/Effect.hs
@@ -0,0 +1,109 @@
+module Effectful.Zoo.Log.Static.Effect
+  ( Log,
+    runLog,
+    runLogToHandle,
+    runLogToStdout,
+    runLogToStderr,
+    withLog,
+    logMessage,
+    localLog,
+  ) where
+
+import Data.Kind
+import Data.Text.IO qualified as T
+import Effectful
+import Effectful.Dispatch.Static
+import Effectful.Zoo.Core
+import Effectful.Zoo.Log.Data.Logger
+import Effectful.Zoo.Log.Data.LogMessage
+import GHC.Stack qualified as GHC
+import HaskellWorks.Prelude
+import System.IO qualified as IO
+
+data Log (i :: Type) :: Effect
+
+type instance DispatchOf (Log i) = Static NoSideEffects
+
+newtype instance StaticRep (Log i) = Log (Logger i)
+
+runLog :: forall i a r. ()
+  => r <: IOE
+  => HasCallStack
+  => UnliftStrategy
+  -> (CallStack -> LogMessage i -> Eff r ())
+  -> Eff (Log i : r) a
+  -> Eff r a
+runLog strategy run f = do
+  s <- mkLogger strategy run
+  evalStaticRep (Log s) f
+
+runLogToHandle :: ()
+  => HasCallStack
+  => Handle
+  -> (LogMessage a -> Text)
+  -> Eff (Log a : r) a
+  -> Eff r a
+runLogToHandle h f =
+  evalStaticRep $ Log $ Logger $ \_ m ->
+    T.hPutStrLn h $ f m
+
+runLogToStdout :: ()
+  => HasCallStack
+  => (LogMessage a -> Text)
+  -> Eff (Log a : r) a
+  -> Eff r a
+runLogToStdout =
+  runLogToHandle IO.stdout
+
+runLogToStderr :: ()
+  => HasCallStack
+  => (LogMessage a -> Text)
+  -> Eff (Log a : r) a
+  -> Eff r a
+runLogToStderr =
+  runLogToHandle IO.stderr
+
+withDataLogSerialiser :: ()
+  => HasCallStack
+  => (Logger i -> Logger o)
+  -> Eff (Log o : r) a
+  -> Eff (Log i : r) a
+withDataLogSerialiser f m = do
+  logger <- getLogger
+  let _ = logger
+  raise $ evalStaticRep (Log (f logger)) m
+
+withLog :: ()
+  => HasCallStack
+  => (o -> i)
+  -> Eff (Log o : r) a
+  -> Eff (Log i : r) a
+withLog =
+  withDataLogSerialiser . contramap
+
+getLogger :: ()
+  => HasCallStack
+  => r <: Log i
+  => Eff r (Logger i)
+getLogger = do
+  Log i <- getStaticRep
+  pure i
+
+logMessage :: ()
+  => HasCallStack
+  => r <: Log i
+  => LogMessage i
+  -> Eff r ()
+logMessage m =
+  withFrozenCallStack do
+    dataLogger <- getLogger
+    unsafeEff_ $ dataLogger.run GHC.callStack m
+
+localLog :: ()
+  => HasCallStack
+  => r <: Log i
+  => (i -> i)
+  -> Eff r a
+  -> Eff r a
+localLog f =
+  localStaticRep $ \(Log s) -> Log (contramap f s)
diff --git a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Internal/Cabal.hs b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Internal/Cabal.hs
--- a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Internal/Cabal.hs
+++ b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Internal/Cabal.hs
@@ -14,7 +14,7 @@
 import Effectful.Zoo.FileSystem
 import Effectful.Zoo.Hedgehog.Api.Internal.Cabal.Types
 import Effectful.Zoo.Hedgehog.Api.Internal.FilePath
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import HaskellWorks.Error.Types
 import HaskellWorks.Prelude
 import System.FilePath (takeDirectory, (</>))
diff --git a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Journal.hs b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Journal.hs
--- a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Journal.hs
+++ b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Journal.hs
@@ -70,8 +70,8 @@
 import Effectful.Concurrent
 import Effectful.Dispatch.Dynamic
 import Effectful.Zoo.Core
-import Effectful.Zoo.DataLog.Dynamic
-import Effectful.Zoo.DataLog.Dynamic qualified as DataLog
+import Effectful.Zoo.DataLog.Static
+import Effectful.Zoo.DataLog.Static qualified as DataLog
 import Effectful.Zoo.Error.Static
 import Effectful.Zoo.Hedgehog.Api.Hedgehog
 import Effectful.Zoo.Hedgehog.Data.PackagePath
diff --git a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Process.hs b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Process.hs
--- a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Process.hs
+++ b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Process.hs
@@ -30,7 +30,7 @@
 import Effectful.Zoo.Hedgehog.Api.Journal
 import Effectful.Zoo.Hedgehog.Api.Process.Internal
 import Effectful.Zoo.Hedgehog.Effect.Hedgehog
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import Effectful.Zoo.Process
 import GHC.Stack (callStack)
 import HaskellWorks.Error.Types
diff --git a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Workspace.hs b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Workspace.hs
--- a/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Workspace.hs
+++ b/components/hedgehog/Effectful/Zoo/Hedgehog/Api/Workspace.hs
@@ -23,7 +23,7 @@
 import Effectful.Zoo.Hedgehog.Data.ProjectRoot
 import Effectful.Zoo.Hedgehog.Data.Workspace
 import Effectful.Zoo.Hedgehog.Effect.Hedgehog
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import HaskellWorks.Prelude
 import Hedgehog.Internal.Property qualified as H
 import System.FilePath ((</>))
diff --git a/components/hedgehog/Effectful/Zoo/Hedgehog/Effect/Run.hs b/components/hedgehog/Effectful/Zoo/Hedgehog/Effect/Run.hs
--- a/components/hedgehog/Effectful/Zoo/Hedgehog/Effect/Run.hs
+++ b/components/hedgehog/Effectful/Zoo/Hedgehog/Effect/Run.hs
@@ -28,7 +28,7 @@
 import Effectful.Zoo.Hedgehog.Effect.Hedgehog
 import Effectful.Zoo.Hedgehog.Effect.HedgehogGen
 import Effectful.Zoo.Log.Data.LogMessage
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import Effectful.Zoo.Resource
 import HaskellWorks.Control.Monad
 import HaskellWorks.Prelude
diff --git a/components/rds-data-test/Effectful/Zoo/RdsData/Test/Cluster.hs b/components/rds-data-test/Effectful/Zoo/RdsData/Test/Cluster.hs
--- a/components/rds-data-test/Effectful/Zoo/RdsData/Test/Cluster.hs
+++ b/components/rds-data-test/Effectful/Zoo/RdsData/Test/Cluster.hs
@@ -35,7 +35,7 @@
 import Effectful.Zoo.Amazonka.Data.AwsLogEntry
 import Effectful.Zoo.Amazonka.Dynamic
 import Effectful.Zoo.Core
-import Effectful.Zoo.DataLog.Dynamic
+import Effectful.Zoo.DataLog.Static
 import Effectful.Zoo.Error.Static
 import Effectful.Zoo.Hedgehog.Api.Assert
 import Effectful.Zoo.Hedgehog.Api.Failure
@@ -77,28 +77,6 @@
     sendAws createDbClusterRequest
       & trapFail @AwsError
       & jotShowDataLog @AwsLogEntry
-
-
-  -- sendAws :: forall a r. ()
-  --   => HasCallStack
-  --   => AwsRequest a
-  --   => r <: Amazonka
-  --   => r <: DataLog AwsLogEntry
-  --   => r <: Error AwsError
-  --   => r <: IOE
-  --   => Typeable (AwsResponse a)
-  --   => Typeable a
-  --   => a
-  --   -> Eff r (AwsResponse a)
-
-  -- jotShowDataLog :: forall i a r. ()
-  --   => HasCallStack
-  --   => Show i
-  --   => r <: Concurrent
-  --   => r <: Error Failure
-  --   => r <: Hedgehog
-  --   => Eff (DataLog i : r) a
-  --   -> Eff r a
 
   let secretName = "my-aurora-cluster"
 
diff --git a/components/rds-data-test/Effectful/Zoo/RdsData/Test/Workspace.hs b/components/rds-data-test/Effectful/Zoo/RdsData/Test/Workspace.hs
--- a/components/rds-data-test/Effectful/Zoo/RdsData/Test/Workspace.hs
+++ b/components/rds-data-test/Effectful/Zoo/RdsData/Test/Workspace.hs
@@ -17,7 +17,7 @@
 import Effectful.Zoo.Hedgehog.Api
 import Effectful.Zoo.Hedgehog.Api.Workspace
 import Effectful.Zoo.Hedgehog.Effect.Hedgehog
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import Effectful.Zoo.Reader.Static
 import HaskellWorks.Prelude
 
diff --git a/components/rds-data/Effectful/Zoo/RdsData/Core.hs b/components/rds-data/Effectful/Zoo/RdsData/Core.hs
--- a/components/rds-data/Effectful/Zoo/RdsData/Core.hs
+++ b/components/rds-data/Effectful/Zoo/RdsData/Core.hs
@@ -24,10 +24,10 @@
 import Effectful.Zoo.Amazonka.Data
 import Effectful.Zoo.Amazonka.Dynamic
 import Effectful.Zoo.Core
-import Effectful.Zoo.DataLog.Dynamic
+import Effectful.Zoo.DataLog.Static
 import Effectful.Zoo.Error.Static
 import Effectful.Zoo.Log.Api
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import Effectful.Zoo.RdsData.Errors
 import HaskellWorks.Prelude
 import Lens.Micro
diff --git a/components/rds-data/Effectful/Zoo/RdsData/Migration.hs b/components/rds-data/Effectful/Zoo/RdsData/Migration.hs
--- a/components/rds-data/Effectful/Zoo/RdsData/Migration.hs
+++ b/components/rds-data/Effectful/Zoo/RdsData/Migration.hs
@@ -27,10 +27,10 @@
 import Effectful.Zoo.Amazonka.Data
 import Effectful.Zoo.Amazonka.Dynamic
 import Effectful.Zoo.Core
-import Effectful.Zoo.DataLog.Dynamic
+import Effectful.Zoo.DataLog.Static
 import Effectful.Zoo.FileSystem
 import Effectful.Zoo.Log.Api
-import Effectful.Zoo.Log.Dynamic
+import Effectful.Zoo.Log.Static
 import Effectful.Zoo.RdsData.Core
 import Effectful.Zoo.RdsData.Errors
 import HaskellWorks.Prelude
diff --git a/effectful-zoo.cabal b/effectful-zoo.cabal
--- a/effectful-zoo.cabal
+++ b/effectful-zoo.cabal
@@ -1,7 +1,7 @@
 cabal-version: 3.4
 
 name:                   effectful-zoo
-version:                0.0.3.1
+version:                0.0.4.0
 synopsis:               Effectful effects for testing
 description:            See https://hackage.haskell.org/package/effectful-zoo/docs/effectful-zoo.html
 category:               Development
@@ -150,10 +150,15 @@
                         Effectful.Zoo.Console.Static
                         Effectful.Zoo.Core
                         Effectful.Zoo.DataLog.Api
+                        Effectful.Zoo.DataLog.Api.Json
                         Effectful.Zoo.DataLog.Data.DataLogger
                         Effectful.Zoo.DataLog.Data.LogEntry
                         Effectful.Zoo.DataLog.Dynamic
+                        Effectful.Zoo.DataLog.Dynamic.Api
+                        Effectful.Zoo.DataLog.Dynamic.Effect
                         Effectful.Zoo.DataLog.Static
+                        Effectful.Zoo.DataLog.Static.Api
+                        Effectful.Zoo.DataLog.Static.Effect
                         Effectful.Zoo.Environment
                         Effectful.Zoo.Error.Dynamic
                         Effectful.Zoo.Error.Static
@@ -164,16 +169,16 @@
                         Effectful.Zoo.Function
                         Effectful.Zoo.Lazy.Dynamic
                         Effectful.Zoo.Log.Api
-                        Effectful.Zoo.Log.Api.Generic
-                        Effectful.Zoo.Log.Api.LazyText
                         Effectful.Zoo.Log.Api.Render
-                        Effectful.Zoo.Log.Api.String
-                        Effectful.Zoo.Log.Api.Text
                         Effectful.Zoo.Log.Data.Logger
                         Effectful.Zoo.Log.Data.LogMessage
                         Effectful.Zoo.Log.Data.Severity
                         Effectful.Zoo.Log.Dynamic
+                        Effectful.Zoo.Log.Dynamic.Api
+                        Effectful.Zoo.Log.Dynamic.Effect
                         Effectful.Zoo.Log.Static
+                        Effectful.Zoo.Log.Static.Api
+                        Effectful.Zoo.Log.Static.Effect
                         Effectful.Zoo.Prim
                         Effectful.Zoo.Process
                         Effectful.Zoo.Reader.Static