packages feed

eventlog-live-0.11.0.0: src-app/GHC/Eventlog/Live/App/Exporter/Otlp.hs

module GHC.Eventlog.Live.App.Exporter.Otlp (
  exportToOtlp,
) where

import Data.DList qualified as D
import Data.Machine (ProcessT, asParts, mapping, (~>))
import Data.Maybe (catMaybes, mapMaybe)
import Data.Text qualified as T
import Data.Version (showVersion)
import GHC.Eventlog.Live.App.Environment (PerSignal, Signal (..), forSignal)
import GHC.Eventlog.Live.App.Exporter.Otlp.Core (Exporter, messageWith, toMaybeKeyValues)
import GHC.Eventlog.Live.App.Exporter.Otlp.Logs (exportResourceLogs, toExportLogsServiceRequest, toLogRecords, toResourceLogs, toScopeLogs)
import GHC.Eventlog.Live.App.Exporter.Otlp.Metrics (exportResourceMetrics, toExportMetricsServiceRequest, toMetric, toResourceMetrics, toScopeMetrics)
import GHC.Eventlog.Live.App.Exporter.Otlp.Profiles (exportResourceProfiles, toExportProfileServiceRequest, toProfiles, toProfilesData, toResourceProfiles, toScopeProfiles)
import GHC.Eventlog.Live.App.Exporter.Otlp.Traces (exportResourceSpans, toExportTracesServiceRequest, toResourceSpans, toScopeSpans, toSpans)
import GHC.Eventlog.Live.Config (FullConfig (..))
import GHC.Eventlog.Live.Config qualified as C
import GHC.Eventlog.Live.Logger (Logger)
import GHC.Eventlog.Live.Machine.Core (Tick)
import GHC.Eventlog.Live.Machine.Core qualified as M
import GHC.Eventlog.Live.Processor (ExportRequest (..), InstrumentationScope (..), Resource (..), Telemetry (..))
import GHC.Eventlog.Live.Processor.Core
import GHC.Eventlog.Live.Types.Logs (SomeLogs)
import GHC.Eventlog.Live.Types.Metrics (SomeMetrics)
import GHC.Eventlog.Live.Types.Profiles (SomeSamples)
import GHC.Eventlog.Live.Types.Traces (SomeSpans)
import Lens.Family2 ((.~))
import Proto.Opentelemetry.Proto.Common.V1.Common qualified as OC
import Proto.Opentelemetry.Proto.Common.V1.Common_Fields qualified as OC
import Proto.Opentelemetry.Proto.Logs.V1.Logs qualified as OL
import Proto.Opentelemetry.Proto.Metrics.V1.Metrics qualified as OM
import Proto.Opentelemetry.Proto.Profiles.V1development.Profiles qualified as OP
import Proto.Opentelemetry.Proto.Resource.V1.Resource qualified as OR
import Proto.Opentelemetry.Proto.Resource.V1.Resource_Fields qualified as OR
import Proto.Opentelemetry.Proto.Trace.V1.Trace qualified as OT

{- |
Convert a `Resource` to an OTLP `OR.Resource`.
-}
toResource :: Resource -> OR.Resource
toResource Resource{..} =
  messageWith [OR.attributes .~ toMaybeKeyValues attrs]

toInstrumentationScope :: InstrumentationScope -> OC.InstrumentationScope
toInstrumentationScope InstrumentationScope{..} =
  messageWith
    [ OC.name .~ name
    , OC.version .~ T.pack (showVersion version)
    ]

data ResourceTelemetry
  = ResourceTelemetry'Logs OL.ResourceLogs
  | ResourceTelemetry'Metrics OM.ResourceMetrics
  | ResourceTelemetry'Spans OT.ResourceSpans
  | ResourceTelemetry'Profile OP.ProfilesData

{- |
Internal helper.
Export resource telemetry data and yield statistics.
-}
exportToOtlp ::
  Logger IO ->
  FullConfig ->
  PerSignal (Maybe Exporter) ->
  ProcessT IO (Tick ExportRequest) (Tick ())
exportToOtlp logger fullConfig exporters =
  M.liftTick (mapping (toResourceTelemetry fullConfig) ~> asParts)
    ~> M.fanoutTick
      [ -- Export logs.
        runIf (C.shouldExportLogs fullConfig) $
          runWith (exporters `forSignal` LOGS) $ \logsExporter ->
            M.liftTick (mapping getResourceLogs ~> asParts ~> mapping D.singleton)
              -- NOTE: This is required to combine different resource telemetry
              --       streams. However, it has the "unfortunate" side-effect of
              --       making it impossible to not batch once per interval.
              ~> M.batchByTick
              ~> M.liftTick
                ( mapping (toExportLogsServiceRequest . D.toList)
                    ~> exportResourceLogs logger logsExporter
                )
      , -- Export metrics.
        runIf (C.shouldExportMetrics fullConfig) $
          runWith (exporters `forSignal` METRICS) $ \metricsExporter ->
            M.liftTick (mapping getResourceMetrics ~> asParts ~> mapping D.singleton)
              -- NOTE: See note above.
              ~> M.batchByTick
              ~> M.liftTick
                ( mapping (toExportMetricsServiceRequest . D.toList)
                    ~> exportResourceMetrics logger metricsExporter
                )
      , -- Export spans.
        runIf (C.shouldExportTraces fullConfig) $
          runWith (exporters `forSignal` TRACES) $ \tracesExporter ->
            M.liftTick (mapping getResourceSpans ~> asParts ~> mapping D.singleton)
              -- NOTE: See note above.
              ~> M.batchByTick
              ~> M.liftTick
                ( mapping (toExportTracesServiceRequest . D.toList)
                    ~> exportResourceSpans logger tracesExporter
                )
      , -- Export profiles.
        runIf (C.shouldExportProfiles fullConfig) $
          runWith (exporters `forSignal` PROFILES) $ \profilesExporter ->
            M.liftTick
              ( mapping getResourceProfiles
                  ~> asParts
                  ~> mapping toExportProfileServiceRequest
                  ~> exportResourceProfiles logger profilesExporter
              )
      ]

getResourceLogs :: ResourceTelemetry -> Maybe OL.ResourceLogs
getResourceLogs = \case
  (ResourceTelemetry'Logs resourceLogs) -> Just resourceLogs
  _otherwise -> Nothing

getResourceMetrics :: ResourceTelemetry -> Maybe OM.ResourceMetrics
getResourceMetrics = \case
  (ResourceTelemetry'Metrics resourceMetrics) -> Just resourceMetrics
  _otherwise -> Nothing

getResourceSpans :: ResourceTelemetry -> Maybe OT.ResourceSpans
getResourceSpans = \case
  (ResourceTelemetry'Spans resourceSpans) -> Just resourceSpans
  _otherwise -> Nothing

getResourceProfiles :: ResourceTelemetry -> Maybe OP.ProfilesData
getResourceProfiles = \case
  (ResourceTelemetry'Profile profilesData) -> Just profilesData
  _otherwise -> Nothing

{- |
Internal helper.

Repack `Telemetry` into batched `ResourceTelemetry`.
-}
toResourceTelemetry ::
  FullConfig ->
  ExportRequest ->
  [ResourceTelemetry]
toResourceTelemetry fullConfig ExportRequest{..} =
  catMaybes [maybeResourceLogs, maybeResourceMetrics, maybeResourceSpans, maybeProfiles]
 where
  (someLogs, someMetrics, someSpans, someSamples) = partitionTelemetry telemetry
  resource' = toResource resource
  scope' = toInstrumentationScope scope

  maybeResourceLogs = do
    let logRecords = concatMap (toLogRecords fullConfig) someLogs
    scopeLogs <- toScopeLogs scope' logRecords
    resourceLogs <- toResourceLogs resource' [scopeLogs]
    pure $ ResourceTelemetry'Logs resourceLogs
  maybeResourceMetrics = do
    let metrics = mapMaybe (toMetric fullConfig) someMetrics
    scopeMetrics <- toScopeMetrics scope' metrics
    resourceMetrics <- toResourceMetrics resource' [scopeMetrics]
    pure $ ResourceTelemetry'Metrics resourceMetrics
  maybeResourceSpans = do
    let spans = concatMap (toSpans fullConfig) someSpans
    scopeSpans <- toScopeSpans scope' spans
    resourceSpans <- toResourceSpans resource' [scopeSpans]
    pure $ ResourceTelemetry'Spans resourceSpans
  maybeProfiles = do
    (profiles, dictionary) <- toProfiles fullConfig someSamples
    scopeProfiles <- toScopeProfiles scope' profiles
    resourceProfiles <- toResourceProfiles resource' [scopeProfiles]
    profilesData <- toProfilesData [resourceProfiles] dictionary
    pure $ ResourceTelemetry'Profile profilesData

{- |
Partition a stream of `Telemetry` batches to individual batches for each kind of telemetry data.
-}
partitionTelemetry :: [Telemetry] -> ([SomeLogs], [SomeMetrics], [SomeSpans], [SomeSamples])
partitionTelemetry = go ([], [], [], [])
 where
  go :: ([SomeLogs], [SomeMetrics], [SomeSpans], [SomeSamples]) -> [Telemetry] -> ([SomeLogs], [SomeMetrics], [SomeSpans], [SomeSamples])
  go (logsRev, metricsRev, spansRev, samplesRev) = \case
    [] -> (reverse logsRev, reverse metricsRev, reverse spansRev, reverse samplesRev)
    (Telemetry'Logs log_ : rest) -> go (log_ : logsRev, metricsRev, spansRev, samplesRev) rest
    (Telemetry'Metrics metric : rest) -> go (logsRev, metric : metricsRev, spansRev, samplesRev) rest
    (Telemetry'Spans spans : rest) -> go (logsRev, metricsRev, spans : spansRev, samplesRev) rest
    (Telemetry'Samples sample : rest) -> go (logsRev, metricsRev, spansRev, sample : samplesRev) rest