packages feed

kenshou-telemetry-0.1.0.0: src/Kenshou/Telemetry/Tracing/Probe.hs

module Kenshou.Telemetry.Tracing.Probe
  ( SpanView (..),
    SpanProbe,
    newSpanProbe,
    readSpans,
    spansSeen,
  )
where

import Data.Foldable qualified as Foldable
import Data.IORef
import Data.Sequence (Seq (..), (|>))
import Data.Sequence qualified as Seq
import Data.Text (Text)
import Data.Word (Word64)
import OpenTelemetry.Attributes (Attributes)
import OpenTelemetry.Common (optionalTimestampToMaybe, timestampToNanoseconds)
import OpenTelemetry.Internal.Common.Types (FlushResult (FlushSuccess), ShutdownResult (ShutdownSuccess))
import OpenTelemetry.Processor.Span (SpanProcessor (..))
import OpenTelemetry.Trace.Core (ImmutableSpan (..), SpanContext (..), SpanHot (..), SpanKind, SpanStatus, getSpanContext)
import OpenTelemetry.Trace.Id (SpanId, TraceId)

data SpanView = SpanView
  { name :: Text,
    kind :: SpanKind,
    traceId :: TraceId,
    spanId :: SpanId,
    parentSpanId :: Maybe SpanId,
    attributes :: Attributes,
    startNs :: Word64,
    endNs :: Word64,
    status :: SpanStatus
  }
  deriving stock (Eq, Show)

-- Evict during capture, even when nobody reads the probe during a long run.
-- A strict IORef update alone only forces the outer constructor.
data ProbeState = ProbeState {seen :: !Int, retained :: !(Seq SpanView)}

data SpanProbe = SpanProbe {capacity :: Int, state :: IORef ProbeState}

newSpanProbe :: Int -> IO (SpanProbe, SpanProcessor)
newSpanProbe capacity = do
  state <- newIORef (ProbeState 0 Seq.empty)
  let probe = SpanProbe (max 0 capacity) state
      processor =
        SpanProcessor
          { spanProcessorOnStart = \_ _ -> pure (),
            spanProcessorOnEnd = capture probe,
            spanProcessorShutdown = pure ShutdownSuccess,
            spanProcessorForceFlush = pure FlushSuccess
          }
  pure (probe, processor)

readSpans :: SpanProbe -> IO [SpanView]
readSpans probe = toList . (.retained) <$> readIORef probe.state
  where
    toList = Foldable.toList

spansSeen :: SpanProbe -> IO Int
spansSeen probe = (.seen) <$> readIORef probe.state

capture :: SpanProbe -> ImmutableSpan -> IO ()
capture probe spanValue = do
  hot <- readIORef spanValue.spanHot
  parent <- traverse getSpanContext spanValue.spanParent
  let view =
        SpanView
          { name = hot.hotName,
            kind = spanValue.spanKind,
            traceId = spanValue.spanContext.traceId,
            spanId = spanValue.spanContext.spanId,
            parentSpanId = (.spanId) <$> parent,
            attributes = hot.hotAttributes,
            startNs = timestampToNanoseconds spanValue.spanStart,
            endNs = maybe (timestampToNanoseconds spanValue.spanStart) timestampToNanoseconds (optionalTimestampToMaybe hot.hotEnd),
            status = hot.hotStatus
          }
  atomicModifyIORef' probe.state \current ->
    let appended = current.retained |> view
        trimmed = if Seq.length appended > probe.capacity then Seq.drop 1 appended else appended
     in (ProbeState (current.seen + 1) trimmed, ())