packages feed

kenshou-measure-0.1.0.0: src/Kenshou/Measure/Selftest/PgInsert.hs

module Kenshou.Measure.Selftest.PgInsert (pgInsertScenario) where

import Control.Exception (bracket)
import Data.Int (Int64)
import Data.List.NonEmpty (NonEmpty (..))
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Text.IO qualified as Text
import Data.Word (Word64)
import Hasql.Connection qualified as Connection
import Hasql.Connection.Settings qualified as Settings
import Hasql.Decoders qualified as Decoders
import Hasql.Encoders qualified as Encoders
import Hasql.Session qualified as Session
import Hasql.Statement qualified as Statement
import Kenshou.Core.Context (RunContext (..), requirePostgres)
import Kenshou.Core.Dimension
import Kenshou.Core.Env
import Kenshou.Core.Env.Postgres (PostgresEnv (..))
import Kenshou.Core.Id (Kind (Benchmark), parseScenarioId)
import Kenshou.Core.Knob
import Kenshou.Core.Phase qualified as Core
import Kenshou.Core.Scenario
import Kenshou.Measure.Knobs
import Kenshou.Measure.Load
import Kenshou.Measure.Recorder
import Kenshou.Measure.Sampler.Postgres
import Kenshou.Measure.Session
import System.Directory (doesFileExist)
import System.FilePath ((</>))

pgInsertScenario :: Scenario
pgInsertScenario =
  Scenario
    { id = either (error . show) id (parseScenarioId "selftest/measure/benchmark/pg-insert"),
      revision = 2,
      summary = "Verifies runtime, process, host, and PostgreSQL measurement series.",
      tier = TierSmoke,
      placement = PlaceEither,
      knobs = loadKnobs (defaultLoadDefaults {model = "closed", workers = 8}) <> measureKnobs Benchmark <> [payloadKnob],
      dimensions = postgresDimensions (PgDurable :| []) (Pg17 :| [Pg18]) telemetryOff,
      phases = Core.PhasePlan 3 15 2,
      requires = pgRequirements,
      knownDefect = Nothing,
      run = runPgInsert
    }

runPgInsert :: RunContext -> IO ScenarioReport
runPgInsert context = case (loadModelFromKnobs context.knobs, measureConfigFromKnobs context (phasePlanFromCore context.phases)) of
  (Left message, _) -> pure (failedWith ["invalid-load-config"] message)
  (_, Left message) -> pure (failedWith ["invalid-measure-config"] message)
  (Right loadModel, Right baseConfig) -> do
    let environment = requirePostgres context
        workers = case loadModel of ClosedLoop closed -> closed.workers; OpenLoop open -> open.executors
        payloadBytes = knobInt context.knobs (name "pg-insert.payload-bytes")
        settings = Settings.connectionString environment.connectionString <> Settings.applicationName "kenshou-selftest-writer"
        config = watchInserts baseConfig
    acquired <- acquireMany workers settings
    case acquired of
      Left message -> pure (infrastructureFailureBecause message)
      Right [] -> pure (infrastructureFailureBecause "load.workers produced no PostgreSQL connections")
      Right connections@(firstConnection : _) -> bracket (pure connections) (mapM_ Connection.release) \openConnections -> do
        setup <- Connection.use firstConnection setupSession
        case setup of
          Left err -> pure (infrastructureFailureBecause (Text.pack (show err)))
          Right () -> do
            let operation = Operation (OpName "insert") (insertOne openConnections payloadBytes)
            (_, report) <- withMeasurement context config (\measurement -> runLoad measurement loadModel operation)
            counted <- Connection.use firstConnection (Session.statement () countRows)
            assess context report counted

insertOne :: [Connection.Connection] -> Int64 -> Int -> Word64 -> IO OpResult
insertOne connections payloadBytes worker sequenceNumber = do
  let connection = connections !! (worker `mod` length connections)
      parameter = Text.intercalate "," [Text.pack (show worker), Text.pack (show sequenceNumber), Text.pack (show payloadBytes)]
  result <- Connection.use connection (Session.statement parameter insertRow)
  pure (either (const (OpFailed (ErrorCause "postgres"))) (const (OpOk 1)) result)

assess :: RunContext -> MeasurementReport -> Either error Int64 -> IO ScenarioReport
assess context report counted = do
  seriesOk <- and <$> traverse hasRows expectedSeries
  let successful = case report.recorder.operations of
        operation : _ -> sum [successes | (successes, _, _) <- Map.elems operation.phaseCounts]
        [] -> 0
      rowCount = either (const Nothing) (Just . fromIntegral) counted
      failures = ["row-count" | rowCount /= Just successful] <> ["series-rows" | not seriesOk]
      scenarioReport = if null failures then passed else failedWith failures ("row count=" <> showText rowCount <> ", recorded successes=" <> showText successful)
  pure (scenarioReport {outcome = measuredOutcome report scenarioReport.outcome})
  where
    expectedSeries = ["sampler.csv", "rts.csv", "proc.csv", "load.csv", "pg-activity.csv", "pg-checkpointer.csv", "pg-wal.csv", "pg-database.csv", "pg-relations.csv", "pg-statements.csv"]
    hasRows file = do
      let path = context.outDir </> "series" </> file
      exists <- doesFileExist path
      if not exists then pure False else (> 2) . length . Text.lines <$> Text.readFile path

acquireMany :: Int -> Settings.Settings -> IO (Either Text [Connection.Connection])
acquireMany count settings = go count []
  where
    go 0 acquired = pure (Right (reverse acquired))
    go remaining acquired = do
      result <- Connection.acquire settings
      case result of
        Left err -> mapM_ Connection.release acquired >> pure (Left (Text.pack (show err)))
        Right connection -> go (remaining - 1) (connection : acquired)

setupSession :: Session.Session ()
setupSession = do
  Session.statement () (unitStatement "CREATE SCHEMA IF NOT EXISTS kenshou_selftest")
  Session.statement () (unitStatement "CREATE TABLE IF NOT EXISTS kenshou_selftest.inserts (id bigserial PRIMARY KEY, worker int NOT NULL, seq bigint NOT NULL, payload bytea NOT NULL)")
  Session.statement () (unitStatement "TRUNCATE kenshou_selftest.inserts")

unitStatement :: Text -> Statement.Statement () ()
unitStatement sql = Statement.unpreparable sql Encoders.noParams Decoders.noResult

insertRow :: Statement.Statement Text ()
insertRow =
  Statement.unpreparable
    "INSERT INTO kenshou_selftest.inserts(worker,seq,payload) VALUES (split_part($1,',',1)::int, split_part($1,',',2)::bigint, decode(repeat('00',split_part($1,',',3)::int),'hex'))"
    (Encoders.param (Encoders.nonNullable Encoders.text))
    Decoders.noResult

countRows :: Statement.Statement () Int64
countRows = Statement.unpreparable "SELECT count(*)::bigint FROM kenshou_selftest.inserts" Encoders.noParams (Decoders.singleRow (Decoders.column (Decoders.nonNullable Decoders.int8)))

payloadKnob :: KnobSpec
payloadKnob = KnobSpec (name "pg-insert.payload-bytes") "Inserted payload size" KnobInt (VInt 256) (IntRange 1 65_536) []

telemetryOff :: DimensionSupport
telemetryOff =
  DimensionSupport
    (Supported (Support (TracingOff :| []) TracingOff))
    (Supported (Support (MetricsOff :| []) MetricsOff))
    NotApplicable
    NotApplicable

pgRequirements :: EnvRequirements
pgRequirements = EnvRequirements (Just (PostgresRequirement [] [("shared_preload_libraries", "'pg_stat_statements'")] False)) [] []

name :: Text -> KnobName
name = either (error . show) id . mkKnobName

showText :: (Show value) => value -> Text
showText = Text.pack . show

watchInserts :: MeasureConfig -> MeasureConfig
watchInserts (MeasureConfig phases histogram rawSamples sampleInterval intervalSeconds postgres extraSamplers healthConfig) =
  MeasureConfig phases histogram rawSamples sampleInterval intervalSeconds (fmap addRelation postgres) extraSamplers healthConfig
  where
    addRelation :: PgSamplerConfig -> PgSamplerConfig
    addRelation pg = pg {relations = ["kenshou_selftest.inserts"]}