{- |
Module      : GHC.Eventlog.Live.Machine.Sink
Description : Machines for processing eventlog data.
Stability   : experimental
Portability : portable
-}
module GHC.Eventlog.Live.Machine.Sink (
  -- * Eventlog file sink
  fileSink,
  fileSinkBatch,
) where

import Control.Monad.IO.Class (MonadIO (..))
import Data.ByteString qualified as BS
import Data.Machine (ProcessT, await, repeatedly, (~>))
import Data.Void (Void)
import GHC.Eventlog.Live.Machine.Core (Tick (..), dropTick)
import System.IO (Handle)

-------------------------------------------------------------------------------
-- Log file sink

{- |
File sink for optional eventlog log file.
-}
fileSink ::
  (MonadIO m) =>
  Handle ->
  ProcessT m BS.ByteString Void
fileSink :: forall (m :: * -> *).
MonadIO m =>
Handle -> ProcessT m ByteString Void
fileSink Handle
handle = PlanT (Is ByteString) Void m () -> MachineT m (Is ByteString) Void
forall (m :: * -> *) (k :: * -> *) o a.
Monad m =>
PlanT k o m a -> MachineT m k o
repeatedly (PlanT (Is ByteString) Void m ()
 -> MachineT m (Is ByteString) Void)
-> PlanT (Is ByteString) Void m ()
-> MachineT m (Is ByteString) Void
forall a b. (a -> b) -> a -> b
$ PlanT (Is ByteString) Void m ByteString
Plan (Is ByteString) Void ByteString
forall (k :: * -> * -> *) i o. Category k => Plan (k i) o i
await PlanT (Is ByteString) Void m ByteString
-> (ByteString -> PlanT (Is ByteString) Void m ())
-> PlanT (Is ByteString) Void m ()
forall a b.
PlanT (Is ByteString) Void m a
-> (a -> PlanT (Is ByteString) Void m b)
-> PlanT (Is ByteString) Void m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= IO () -> PlanT (Is ByteString) Void m ()
forall a. IO a -> PlanT (Is ByteString) Void m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> PlanT (Is ByteString) Void m ())
-> (ByteString -> IO ())
-> ByteString
-> PlanT (Is ByteString) Void m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> ByteString -> IO ()
BS.hPut Handle
handle

-------------------------------------------------------------------------------
-- Log file sink with batches

{- |
File sink for optional eventlog log file.
-}
fileSinkBatch ::
  (MonadIO m) =>
  Handle ->
  ProcessT m (Tick BS.ByteString) Void
fileSinkBatch :: forall (m :: * -> *).
MonadIO m =>
Handle -> ProcessT m (Tick ByteString) Void
fileSinkBatch Handle
handle = MachineT m (Is (Tick ByteString)) ByteString
forall a (m :: * -> *). Monad m => MachineT m (Is (Tick a)) a
dropTick MachineT m (Is (Tick ByteString)) ByteString
-> ProcessT m ByteString Void
-> MachineT m (Is (Tick ByteString)) Void
forall (m :: * -> *) (k :: * -> *) b c.
Monad m =>
MachineT m k b -> ProcessT m b c -> MachineT m k c
~> Handle -> ProcessT m ByteString Void
forall (m :: * -> *).
MonadIO m =>
Handle -> ProcessT m ByteString Void
fileSink Handle
handle