packages feed

keiro-0.25.0.0: bench/DurableTraceBench.hs

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}

module DurableTraceBench (durableTraceBenchmarks) where

import BenchSetup (selected, setupTrace)
import Contravariant.Extras (contrazip3)
import Control.Monad (forM_, replicateM_, unless, void)
import Data.Aeson qualified as Aeson
import Data.Int (Int32, Int64)
import Data.Map.Strict qualified as Map
import Data.Text qualified as Text
import Data.Text.IO qualified as TextIO
import Data.Time (UTCTime (..))
import Data.Time.Calendar (Day (ModifiedJulianDay))
import Data.UUID qualified as UUID
import Data.Vector qualified as Vector
import Effectful (Eff, IOE, (:>))
import Effectful.Error.Static (Error)
import Hasql.Decoders qualified as D
import Hasql.Encoders qualified as E
import Hasql.Statement (Statement, preparable)
import Keiro.Prelude (liftIO, (&), (.~), (^.))
import Keiro.Telemetry qualified as Telemetry
import Keiro.Test.Postgres (checkpointBenchmarkStore)
import Keiro.Timer qualified as Timer
import Keiro.Workflow qualified as Workflow
import Keiro.Workflow.Instance qualified as Instance
import Keiro.Workflow.Snapshot (writeWorkflowSnapshot)
import Kiroku.Store qualified as Store
import Kiroku.Store.Types (EventId (..), StreamVersion (..))
import OpenTelemetry.Trace.Core (Tracer, defaultSpanArguments, inSpan')
import System.Environment (lookupEnv)
import Test.Tasty.Bench (Benchmark, bench, bgroup, nfIO)
import "hasql-transaction" Hasql.Transaction qualified as Tx

durableTraceBenchmarks :: Store.KirokuStore -> Tracer -> [Benchmark]
durableTraceBenchmarks store tracer =
  [ bgroup "durable-tracing" $
      [timerCell traced | traced <- [False, True]]
        <> [workflowCell size traced | size <- [1 :: Int, 1000], traced <- [False, True]]
  ]
  where
    handle traced = if traced then Just tracer else Nothing
    suffix traced = if traced then "/tracer" else ""
    now = UTCTime (ModifiedJulianDay 60000) 0
    timerCell traced =
      let label = "timer-100" <> suffix traced
          worker = Timer.defaultTimerWorkerOptions & #tracer .~ handle traced & #requeueStuckAfter .~ Nothing
          action = do
            checked store (Store.runTransaction (Tx.sql "TRUNCATE keiro.keiro_timers"))
            Telemetry.withWorkflowSpan (handle traced) (Workflow.WorkflowName "timerBench") (Workflow.WorkflowId "one") Nothing $ \_ -> do
              requests <- traverse (Timer.captureTimerTraceContext (handle traced) . request) [1 .. 100]
              checked store (Store.runTransaction (mapM_ Timer.scheduleTimerTx requests))
            count <- checked store $ Timer.drainDueTimersWith Nothing worker now 101 (const (pure (Just (EventId UUID.nil))))
            unless (count == 100) (fail "timer benchmark did not fire exactly 100 rows")
          request index = Timer.TimerRequest (Timer.TimerId (UUID.fromWords64 0 (fromIntegral index))) "timerBench" "one" now Aeson.Null Nothing
       in selected (warm label action) $ \_ -> bench label (nfIO action)
    workflowCell size traced =
      let label = "resume-snapshot-" <> show size <> suffix traced
          name = Workflow.WorkflowName (Text.pack label)
          wid = Workflow.WorkflowId "one"
          options = Workflow.defaultWorkflowRunOptions & #tracer .~ handle traced
          seed = do
            forM_ [1 .. size] $ \index -> void $ Workflow.step (key index) (pure index)
            void (awaitValue "wake")
          action = replicateM_ 10 do
            checked store (Instance.markInstanceSuspendedAwaitingTraced traced name wid 0 "wake")
            result <- checked store $ Workflow.runWorkflowWith options name wid $ do
              value <- Workflow.step (key 1) (pure (1 :: Int))
              _ <- awaitValue "wake"
              _ <- awaitValue "hold"
              pure value
            unless (result == Workflow.Suspended) (fail "workflow benchmark failed to suspend")
          setup = do
            result <- checked store (Workflow.runWorkflowWith options name wid seed)
            unless (result == Workflow.Suspended) (fail "workflow seed failed to suspend")
            inSpan' tracer "wake" defaultSpanArguments $ \_ ->
              checked store $ Workflow.appendJournalEntryTraced (handle traced) name wid (Workflow.StepRecorded "wake" Aeson.Null now)
            rows <- checked store $ Store.readStreamForward (Workflow.workflowGenerationStreamName name wid 0) (StreamVersion (fromIntegral size)) 1
            unless (Vector.length rows == 1) (fail "workflow seed wake missing")
            let row = Vector.head rows
                state = Map.insert "wake" Aeson.Null (Map.fromList [("step-" <> Text.pack (show index), Aeson.toJSON index) | index <- [1 .. size]])
            checked store (writeWorkflowSnapshot (row ^. #originalStreamId) (row ^. #originalVersion) state)
            diagnostic <- lookupEnv "KEIRO_BENCH_DURABLE_EXPLAIN"
            let explain tag = do
                  plan <- checked store (Store.runTransaction (Tx.statement ((case Workflow.workflowGenerationStreamName name wid 0 of Store.StreamName value -> value), 0, 1) originPlan))
                  putStrLn (label <> " " <> tag)
                  mapM_ TextIO.putStrLn plan
            whenDiagnostic diagnostic (explain "before ANALYZE")
            checked store (Store.runTransaction (Tx.sql "ANALYZE streams; ANALYZE events; ANALYZE stream_events; ANALYZE keiro.keiro_workflows; ANALYZE keiro.keiro_workflow_steps"))
            whenDiagnostic diagnostic (explain "after ANALYZE")
            warm label action
       in selected setup $ \_ -> bench label (nfIO action)
    key index = Workflow.StepName ("step-" <> Text.pack (show index))
    warm label action = do
      checkpointBenchmarkStore store
      setupTrace "durable-tracing" label "warm-up=3; timer rows reset per invocation; resume=10 fixed snapshots"
      replicateM_ 3 action

checked :: Store.KirokuStore -> Eff '[Store.Store, Error Store.StoreError, IOE] a -> IO a
checked store action = Store.runStoreIO store action >>= either (fail . show) pure

awaitValue :: (Workflow.Workflow :> es) => Text.Text -> Eff es Aeson.Value
awaitValue key = Workflow.awaitStep (Workflow.StepName key) (pure ())

whenDiagnostic :: Maybe String -> IO () -> IO ()
whenDiagnostic (Just "1") action = action
whenDiagnostic _ _ = pure ()

-- Same origin query as the registered Kiroku read API, for plan diagnostics.
originPlan :: Statement (Text.Text, Int64, Int32) [Text.Text]
originPlan =
  preparable
    """
    EXPLAIN (ANALYZE, BUFFERS) SELECT e.event_id, e.event_type,
      se.stream_version, 0::bigint AS global_position, se.original_stream_id,
      se.original_stream_version, e.data, e.metadata, e.causation_id, e.correlation_id, e.created_at
    FROM stream_events se JOIN events e ON e.event_id = se.event_id
    JOIN streams s ON s.stream_id = se.stream_id
    WHERE s.stream_name = $1 AND s.deleted_at IS NULL AND se.stream_version > $2
      AND se.stream_version >= s.truncate_before ORDER BY se.stream_version ASC LIMIT $3
    """
    (contrazip3 (E.param (E.nonNullable E.text)) (E.param (E.nonNullable E.int8)) (E.param (E.nonNullable E.int4)))
    (D.rowList (D.column (D.nonNullable D.text)))