packages feed

kenshou-telemetry-0.1.0.0: src/Kenshou/Telemetry/SelfTest/Arms.hs

module Kenshou.Telemetry.SelfTest.Arms (armsScenario) where

import Data.Int (Int64)
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Context (RunContext (..))
import Kenshou.Core.Dimension (allTelemetryArms, noDimensions)
import Kenshou.Core.Env (noEnvironment)
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.Clock (Nanos (..))
import Kenshou.Measure.Health (HealthConfig (..))
import Kenshou.Measure.Knobs
import Kenshou.Measure.Load
import Kenshou.Measure.Phase qualified as Measure
import Kenshou.Measure.Recorder (OpName (..))
import Kenshou.Measure.Session
import Kenshou.Telemetry
import Kenshou.Telemetry.SelfTest.Endpoints (withSyntheticEndpoints)
import Kenshou.Telemetry.SelfTest.Service

armsScenario :: Scenario
armsScenario =
  Scenario
    { id = either (error . Text.unpack) id (parseScenarioId "selftest/telemetry/benchmark/arms-on-synthetic-service"),
      revision = 1,
      summary = "Measures one synthetic service under every tracing and metrics arm.",
      tier = TierSmoke,
      placement = PlaceEither,
      knobs = loadKnobs defaults <> measureKnobs Benchmark <> workKnobs <> telemetryKnobs,
      dimensions = allTelemetryArms noDimensions,
      phases = Core.PhasePlan 0.1 10 0.1,
      requires = noEnvironment,
      knownDefect = Nothing,
      run = runArms
    }
  where
    defaults = defaultLoadDefaults {model = "closed", workers = 4, thinkTimeUs = 0}

runArms :: RunContext -> IO ScenarioReport
runArms context = case (telemetrySpecFromContext context, loadModelFromKnobs context.knobs, measureConfigFromKnobs context phases) of
  (Left message, _, _) -> pure (failedWith ["invalid-telemetry-config"] message)
  (_, Left message, _) -> pure (failedWith ["invalid-load-config"] message)
  (_, _, Left message) -> pure (failedWith ["invalid-measure-config"] message)
  (Right telemetrySpec, Right loadModel, Right measureConfig) ->
    withTelemetry telemetrySpec \telemetry -> do
      withSyntheticEndpoints telemetry.servesEndpoints telemetry.registerEndpoint do
        syntheticMetrics <- traverse newSyntheticMetrics telemetry.meter
        let spanCount = integer "work.spans-per-op"
            attributeCount = integer "work.attributes-per-span"
            cpuMicros = integer "work.cpu-micros"
            operation = Operation (OpName "synthetic") (\_ _ -> runSyntheticOperation telemetry.tracer syntheticMetrics spanCount attributeCount cpuMicros)
        -- This closed-loop benchmark intentionally saturates the measured
        -- process when work.cpu-micros is zero. That CPU is the subject under
        -- test, rather than an overloaded open-loop driver.
        let closedLoopConfig = measureConfig {healthConfig = measureConfig.healthConfig {cpuSoft = 1.1, cpuHard = 1.2}}
        (_, measurement) <- withMeasurement context closedLoopConfig (\session -> runLoad session loadModel operation)
        pure (passed {outcome = measuredOutcome measurement passed.outcome})
  where
    duration = fromIntegral (knobInt context.knobs (name "load.duration-seconds")) * 1_000_000_000
    phases = Measure.PhasePlan (Nanos 100_000_000) (Measure.SteadyFor (Nanos duration)) (Nanos 100_000_000)
    integer key = fromIntegral (knobInt context.knobs (name key))

workKnobs :: [KnobSpec]
workKnobs =
  [ intKnob "work.cpu-micros" "Synthetic CPU work per operation" 1000 0 100000,
    intKnob "work.spans-per-op" "Spans emitted per operation" 2 1 16,
    intKnob "work.attributes-per-span" "Attributes attached to every span" 6 0 64,
    intKnob "load.duration-seconds" "Steady measurement duration" 10 1 3600
  ]

intKnob :: Text -> Text -> Int64 -> Int64 -> Int64 -> KnobSpec
intKnob key summary def low high = KnobSpec (name key) summary KnobInt (VInt def) (IntRange low high) []

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