-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

{- | The provider construction, the lifecycle bracket and the exporter wrappers behind
"Ecluse.Runtime.Telemetry", which documents the substrate and re-exports the curated surface.
Importing this module opts out of that stability promise, the convention @text@ and @bytestring@
use, so production code imports the public one.
-}
module Ecluse.Runtime.Telemetry.Internal (
    -- * Master switch
    TelemetrySwitch (..),
    parseTelemetrySwitch,

    -- * The telemetry handle
    Telemetry (..),
    TelemetryProviders (..),
    telemetryDisabled,
    telemetryEnabled,
    telemetryTracerProvider,
    telemetryMeterProvider,

    -- * Lifecycle
    withTelemetry,
    initializeObservedOpenTelemetryWith,
    initializeMeterWorkers,

    -- * Export-failure observation (exporter wrappers)
    observeSpanExporter,
    observeMetricExporter,
) where

import Control.Exception qualified as Exception
import Katip (LogEnv)
import OpenTelemetry.Environment (lookupBooleanEnv)
import OpenTelemetry.Exporter.Metric (MetricExporter (..))
import OpenTelemetry.Exporter.OTLP.Span (loadExporterEnvironmentVariables, otlpExporter)
import OpenTelemetry.Exporter.Span (SpanExporter (..))
import OpenTelemetry.Log (initializeGlobalLoggerProvider, shutdownLoggerProvider)
import OpenTelemetry.Log.Core (LoggerProvider)
import OpenTelemetry.Metric (
    MeterProvider (..),
    PeriodicMetricReaderHandle (stopPeriodicMetricReader),
    createMeterProvider,
    defaultSdkMeterProviderOptions,
    forkPeriodicMetricReader,
    noopMeterProvider,
    periodicMetricReaderOptionsFromEnv,
    resolveMetricExporter,
    setGlobalMeterProvider,
    shutdownMeterProvider,
 )
import OpenTelemetry.Propagator (setGlobalTextMapPropagator)
import OpenTelemetry.Registry (registerSpanExporterFactory)
import OpenTelemetry.Resource (materializeResources, mergeResources, mkResource)
import OpenTelemetry.Resource.Detect (detectBuiltInResources, detectResourceAttributes)
import OpenTelemetry.SDK (OTelSignals (..))
import OpenTelemetry.Trace (
    TracerProvider,
    TracerProviderOptions (tracerProviderOptionsPropagators),
    createTracerProvider,
    getTracerProviderInitializationOptions,
    setGlobalTracerProvider,
    shutdownTracerProvider,
 )
import UnliftIO (bracket)
import UnliftIO.Async (asyncWithUnmask, cancel)
import UnliftIO.Exception (catchAny)

import Ecluse.Runtime.Telemetry.Batched (batchMeterProvider)
import Ecluse.Runtime.Telemetry.Escape (withEscapeHandler)
import Ecluse.Runtime.Telemetry.ExportFailure (
    ExportFailureSink,
    exportFailureSink,
    installExportErrorHandler,
    observeExportResult,
    observeFlushFault,
 )
import Ecluse.Runtime.Telemetry.Scrape (MetricScrape, metricScrapeFor, withScrapeListener)

import Data.Universe.Class (Universe (..))
import Data.Universe.Generic (universeGeneric)

import Ecluse.Core.Supervision (superviseBackground)
import Ecluse.Core.Wire (WireVocab (..), parseWire)

-- | The @ECLUSE_OBSERVABILITY__TELEMETRY@ master switch. Telemetry is opt-in, so 'TelemetryOff' is the default.
data TelemetrySwitch
    = -- | Telemetry is disabled (the default): nothing is wired and nothing is emitted.
      TelemetryOff
    | -- | Telemetry is enabled: the SDK providers are built from the standard @OTEL_*@ environment and the OTLP exporter is active.
      TelemetryOn
    deriving stock (TelemetrySwitch -> TelemetrySwitch -> Bool
(TelemetrySwitch -> TelemetrySwitch -> Bool)
-> (TelemetrySwitch -> TelemetrySwitch -> Bool)
-> Eq TelemetrySwitch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TelemetrySwitch -> TelemetrySwitch -> Bool
== :: TelemetrySwitch -> TelemetrySwitch -> Bool
$c/= :: TelemetrySwitch -> TelemetrySwitch -> Bool
/= :: TelemetrySwitch -> TelemetrySwitch -> Bool
Eq, (forall x. TelemetrySwitch -> Rep TelemetrySwitch x)
-> (forall x. Rep TelemetrySwitch x -> TelemetrySwitch)
-> Generic TelemetrySwitch
forall x. Rep TelemetrySwitch x -> TelemetrySwitch
forall x. TelemetrySwitch -> Rep TelemetrySwitch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TelemetrySwitch -> Rep TelemetrySwitch x
from :: forall x. TelemetrySwitch -> Rep TelemetrySwitch x
$cto :: forall x. Rep TelemetrySwitch x -> TelemetrySwitch
to :: forall x. Rep TelemetrySwitch x -> TelemetrySwitch
Generic, Int -> TelemetrySwitch -> ShowS
[TelemetrySwitch] -> ShowS
TelemetrySwitch -> String
(Int -> TelemetrySwitch -> ShowS)
-> (TelemetrySwitch -> String)
-> ([TelemetrySwitch] -> ShowS)
-> Show TelemetrySwitch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TelemetrySwitch -> ShowS
showsPrec :: Int -> TelemetrySwitch -> ShowS
$cshow :: TelemetrySwitch -> String
show :: TelemetrySwitch -> String
$cshowList :: [TelemetrySwitch] -> ShowS
showList :: [TelemetrySwitch] -> ShowS
Show)

instance Universe TelemetrySwitch where universe :: [TelemetrySwitch]
universe = [TelemetrySwitch]
forall a. (Generic a, GUniverse (Rep a)) => [a]
universeGeneric

-- Listed @on@ before @off@: that is the order the accepted-set message names them.
instance WireVocab TelemetrySwitch where
    wireKind :: Text
wireKind = Text
"telemetry switch"
    wireTable :: NonEmpty (TelemetrySwitch, Text)
wireTable =
        (TelemetrySwitch
TelemetryOn, Text
"on")
            (TelemetrySwitch, Text)
-> [(TelemetrySwitch, Text)] -> NonEmpty (TelemetrySwitch, Text)
forall a. a -> [a] -> NonEmpty a
:| [(TelemetrySwitch
TelemetryOff, Text
"off")]

{- | Parse a 'TelemetrySwitch' from its wire name. An unrecognised value fails loudly with the
accepted set, never falling back to a mode.

>>> parseTelemetrySwitch "off"
Right TelemetryOff

>>> parseTelemetrySwitch "on"
Right TelemetryOn

>>> parseTelemetrySwitch "maybe"
Left "unknown telemetry switch \"maybe\" (expected one of: on, off)"
-}
parseTelemetrySwitch :: Text -> Either Text TelemetrySwitch
parseTelemetrySwitch :: Text -> Either Text TelemetrySwitch
parseTelemetrySwitch = Text -> Either Text TelemetrySwitch
forall a. WireVocab a => Text -> Either Text a
parseWire

-- | The telemetry handle held in the composition root: the off-by-default no-op or the enabled providers. The disabled case carries no provider, so telemetry is inert rather than unsampled.
data Telemetry
    = -- | The off-by-default no-op: no providers, nothing emitted.
      TelemetryDisabled
    | -- | The enabled handle carrying the SDK's providers, built from the @OTEL_*@ environment, in a product so no selector is partial.
      TelemetryEnabled TelemetryProviders

-- | The SDK providers an enabled 'Telemetry' handle carries: a total product, so its fields are not partial selectors over the 'Telemetry' sum.
data TelemetryProviders = TelemetryProviders
    { TelemetryProviders -> TracerProvider
tpTracerProvider :: TracerProvider
    -- ^ The SDK tracer provider the proxy hangs spans on.
    , TelemetryProviders -> MeterProvider
tpMeterProvider :: MeterProvider
    -- ^ The SDK meter provider the proxy hangs metric instruments on.
    }

-- | The disabled telemetry handle: the off-by-default no-op that holds no providers and emits nothing. This is what an unset @ECLUSE_OBSERVABILITY__TELEMETRY@ resolves to.
telemetryDisabled :: Telemetry
telemetryDisabled :: Telemetry
telemetryDisabled = Telemetry
TelemetryDisabled

-- | Build an enabled telemetry handle from the SDK signals 'withTelemetry' brackets.
telemetryEnabled :: OTelSignals -> Telemetry
telemetryEnabled :: OTelSignals -> Telemetry
telemetryEnabled OTelSignals
signals =
    TelemetryProviders -> Telemetry
TelemetryEnabled
        TelemetryProviders
            { tpTracerProvider :: TracerProvider
tpTracerProvider = OTelSignals -> TracerProvider
otelTracerProvider OTelSignals
signals
            , tpMeterProvider :: MeterProvider
tpMeterProvider = OTelSignals -> MeterProvider
otelMeterProvider OTelSignals
signals
            }

-- | The tracer provider a 'Telemetry' handle exposes, 'Nothing' when telemetry is disabled. 'Nothing' means emit nothing, never fabricate a no-op provider at the edge.
telemetryTracerProvider :: Telemetry -> Maybe TracerProvider
telemetryTracerProvider :: Telemetry -> Maybe TracerProvider
telemetryTracerProvider = \case
    Telemetry
TelemetryDisabled -> Maybe TracerProvider
forall a. Maybe a
Nothing
    TelemetryEnabled TelemetryProviders
providers -> TracerProvider -> Maybe TracerProvider
forall a. a -> Maybe a
Just (TelemetryProviders -> TracerProvider
tpTracerProvider TelemetryProviders
providers)

-- | The meter provider a 'Telemetry' handle exposes, 'Nothing' when telemetry is disabled (the dual of 'telemetryTracerProvider' for metric instruments).
telemetryMeterProvider :: Telemetry -> Maybe MeterProvider
telemetryMeterProvider :: Telemetry -> Maybe MeterProvider
telemetryMeterProvider = \case
    Telemetry
TelemetryDisabled -> Maybe MeterProvider
forall a. Maybe a
Nothing
    TelemetryEnabled TelemetryProviders
providers -> MeterProvider -> Maybe MeterProvider
forall a. a -> Maybe a
Just (TelemetryProviders -> MeterProvider
tpMeterProvider TelemetryProviders
providers)

-- | Run an action with a 'Telemetry' handle bracketed by the 'TelemetrySwitch'. 'TelemetryOff' opens nothing. 'TelemetryOn' builds the providers, runs the scrape listener, and tears both down.
withTelemetry :: TelemetrySwitch -> LogEnv -> (Telemetry -> IO a) -> IO a
withTelemetry :: forall a. TelemetrySwitch -> LogEnv -> (Telemetry -> IO a) -> IO a
withTelemetry TelemetrySwitch
switch LogEnv
logEnv Telemetry -> IO a
use = case TelemetrySwitch
switch of
    TelemetrySwitch
TelemetryOff -> Telemetry -> IO a
use Telemetry
telemetryDisabled
    TelemetrySwitch
TelemetryOn -> do
        sink <- LogEnv -> IO ExportFailureSink
exportFailureSink LogEnv
logEnv
        installExportErrorHandler sink
        registerObservedSpanExporter sink
        bracket (initializeObservedOpenTelemetry logEnv sink) (otelShutdown . fst) $ \(OTelSignals
signals, Maybe MetricScrape
scrape) ->
            LogEnv -> Maybe MetricScrape -> IO a -> IO a
forall a. LogEnv -> Maybe MetricScrape -> IO a -> IO a
withScrapeListener LogEnv
logEnv Maybe MetricScrape
scrape (Telemetry -> IO a
use (OTelSignals -> Telemetry
telemetryEnabled OTelSignals
signals))

{- Wrap the OTLP span exporter so a failed export is observed: @hs-opentelemetry@ 1.0.0.0
discards the 'ExportResult' in the batch processor, so the failure is otherwise invisible. -}
observeSpanExporter :: ExportFailureSink -> SpanExporter -> SpanExporter
observeSpanExporter :: ExportFailureSink -> SpanExporter -> SpanExporter
observeSpanExporter ExportFailureSink
sink SpanExporter
inner =
    SpanExporter
inner
        { spanExporterExport = \HashMap InstrumentationLibrary (Vector ImmutableSpan)
completedSpans -> do
            result <- SpanExporter
-> HashMap InstrumentationLibrary (Vector ImmutableSpan)
-> IO ExportResult
spanExporterExport SpanExporter
inner HashMap InstrumentationLibrary (Vector ImmutableSpan)
completedSpans
            observeExportResult sink "span" result
            pure result
        }

-- Dual of 'observeSpanExporter' for the periodic metric reader's exporter (which likewise
-- discards the 'ExportResult').
observeMetricExporter :: ExportFailureSink -> MetricExporter -> MetricExporter
observeMetricExporter :: ExportFailureSink -> MetricExporter -> MetricExporter
observeMetricExporter ExportFailureSink
sink MetricExporter
inner =
    MetricExporter
inner
        { metricExporterExport = \Vector ResourceMetricsExport
batches -> do
            result <- MetricExporter -> Vector ResourceMetricsExport -> IO ExportResult
metricExporterExport MetricExporter
inner Vector ResourceMetricsExport
batches
            observeExportResult sink "metric" result
            pure result
        }

{- Register the observed OTLP span exporter under the @otlp@ key before the SDK's env-driven
tracer init runs: the registry prefers a registered factory over the built-in default. -}
registerObservedSpanExporter :: ExportFailureSink -> IO ()
registerObservedSpanExporter :: ExportFailureSink -> IO ()
registerObservedSpanExporter ExportFailureSink
sink =
    Text -> IO SpanExporter -> IO ()
registerSpanExporterFactory
        Text
"otlp"
        (ExportFailureSink -> SpanExporter -> SpanExporter
observeSpanExporter ExportFailureSink
sink (SpanExporter -> SpanExporter)
-> IO SpanExporter -> IO SpanExporter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (OTLPExporterConfig -> IO SpanExporter
forall (m :: * -> *).
MonadIO m =>
OTLPExporterConfig -> m SpanExporter
otlpExporter (OTLPExporterConfig -> IO SpanExporter)
-> IO OTLPExporterConfig -> IO SpanExporter
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO OTLPExporterConfig
forall (m :: * -> *). MonadIO m => m OTLPExporterConfig
loadExporterEnvironmentVariables))

{- Mirror @hs-opentelemetry-sdk@ 1.0.0.0's @initializeOpenTelemetry@. The tracer reads the
registry, so 'registerObservedSpanExporter' runs first. Re-diff against the SDK on a bump. -}
initializeObservedOpenTelemetry :: LogEnv -> ExportFailureSink -> IO (OTelSignals, Maybe MetricScrape)
initializeObservedOpenTelemetry :: LogEnv -> ExportFailureSink -> IO (OTelSignals, Maybe MetricScrape)
initializeObservedOpenTelemetry LogEnv
logEnv ExportFailureSink
sink =
    IO (MeterProvider, Maybe MetricScrape)
-> IO LoggerProvider -> IO (OTelSignals, Maybe MetricScrape)
initializeObservedOpenTelemetryWith (LogEnv
-> ExportFailureSink -> IO (MeterProvider, Maybe MetricScrape)
initializeObservedMeterProvider LogEnv
logEnv ExportFailureSink
sink) IO LoggerProvider
initializeGlobalLoggerProvider

-- | Release acquired providers if a later provider fails to initialise.
initializeObservedOpenTelemetryWith :: IO (MeterProvider, Maybe MetricScrape) -> IO LoggerProvider -> IO (OTelSignals, Maybe MetricScrape)
initializeObservedOpenTelemetryWith :: IO (MeterProvider, Maybe MetricScrape)
-> IO LoggerProvider -> IO (OTelSignals, Maybe MetricScrape)
initializeObservedOpenTelemetryWith IO (MeterProvider, Maybe MetricScrape)
acquireMeter IO LoggerProvider
acquireLogger =
    IO TracerProvider
-> (TracerProvider -> IO ())
-> (TracerProvider -> IO (OTelSignals, Maybe MetricScrape))
-> IO (OTelSignals, Maybe MetricScrape)
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
Exception.bracketOnError IO TracerProvider
initializeEscapeHandledTracerProvider (\TracerProvider
provider -> IO ShutdownResult -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (TracerProvider -> Maybe Int -> IO ShutdownResult
forall (m :: * -> *).
MonadIO m =>
TracerProvider -> Maybe Int -> m ShutdownResult
shutdownTracerProvider TracerProvider
provider Maybe Int
forall a. Maybe a
Nothing)) ((TracerProvider -> IO (OTelSignals, Maybe MetricScrape))
 -> IO (OTelSignals, Maybe MetricScrape))
-> (TracerProvider -> IO (OTelSignals, Maybe MetricScrape))
-> IO (OTelSignals, Maybe MetricScrape)
forall a b. (a -> b) -> a -> b
$ \TracerProvider
tracerProvider ->
        IO (MeterProvider, Maybe MetricScrape)
-> ((MeterProvider, Maybe MetricScrape) -> IO ())
-> ((MeterProvider, Maybe MetricScrape)
    -> IO (OTelSignals, Maybe MetricScrape))
-> IO (OTelSignals, Maybe MetricScrape)
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
Exception.bracketOnError IO (MeterProvider, Maybe MetricScrape)
acquireMeter (\(MeterProvider
provider, Maybe MetricScrape
_) -> IO ShutdownResult -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (MeterProvider -> Maybe Int -> IO ShutdownResult
shutdownMeterProvider MeterProvider
provider Maybe Int
forall a. Maybe a
Nothing)) (((MeterProvider, Maybe MetricScrape)
  -> IO (OTelSignals, Maybe MetricScrape))
 -> IO (OTelSignals, Maybe MetricScrape))
-> ((MeterProvider, Maybe MetricScrape)
    -> IO (OTelSignals, Maybe MetricScrape))
-> IO (OTelSignals, Maybe MetricScrape)
forall a b. (a -> b) -> a -> b
$ \(MeterProvider
meterProvider, Maybe MetricScrape
scrape) ->
            IO LoggerProvider
-> (LoggerProvider -> IO ())
-> (LoggerProvider -> IO (OTelSignals, Maybe MetricScrape))
-> IO (OTelSignals, Maybe MetricScrape)
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
Exception.bracketOnError IO LoggerProvider
acquireLogger (\LoggerProvider
provider -> IO ShutdownResult -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (LoggerProvider -> Maybe Int -> IO ShutdownResult
forall (m :: * -> *).
MonadIO m =>
LoggerProvider -> Maybe Int -> m ShutdownResult
shutdownLoggerProvider LoggerProvider
provider Maybe Int
forall a. Maybe a
Nothing)) ((LoggerProvider -> IO (OTelSignals, Maybe MetricScrape))
 -> IO (OTelSignals, Maybe MetricScrape))
-> (LoggerProvider -> IO (OTelSignals, Maybe MetricScrape))
-> IO (OTelSignals, Maybe MetricScrape)
forall a b. (a -> b) -> a -> b
$ \LoggerProvider
loggerProvider -> do
                let shutdown :: IO ()
shutdown = do
                        IO ShutdownResult -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (TracerProvider -> Maybe Int -> IO ShutdownResult
forall (m :: * -> *).
MonadIO m =>
TracerProvider -> Maybe Int -> m ShutdownResult
shutdownTracerProvider TracerProvider
tracerProvider Maybe Int
forall a. Maybe a
Nothing) IO () -> (SomeException -> IO ()) -> IO ()
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> (SomeException -> m a) -> m a
`catchAny` IO () -> SomeException -> IO ()
forall a b. a -> b -> a
const IO ()
forall (f :: * -> *). Applicative f => f ()
pass
                        IO ShutdownResult -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (MeterProvider -> Maybe Int -> IO ShutdownResult
shutdownMeterProvider MeterProvider
meterProvider Maybe Int
forall a. Maybe a
Nothing) IO () -> (SomeException -> IO ()) -> IO ()
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> (SomeException -> m a) -> m a
`catchAny` IO () -> SomeException -> IO ()
forall a b. a -> b -> a
const IO ()
forall (f :: * -> *). Applicative f => f ()
pass
                        IO ShutdownResult -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (LoggerProvider -> Maybe Int -> IO ShutdownResult
forall (m :: * -> *).
MonadIO m =>
LoggerProvider -> Maybe Int -> m ShutdownResult
shutdownLoggerProvider LoggerProvider
loggerProvider Maybe Int
forall a. Maybe a
Nothing) IO () -> (SomeException -> IO ()) -> IO ()
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> (SomeException -> m a) -> m a
`catchAny` IO () -> SomeException -> IO ()
forall a b. a -> b -> a
const IO ()
forall (f :: * -> *). Applicative f => f ()
pass
                (OTelSignals, Maybe MetricScrape)
-> IO (OTelSignals, Maybe MetricScrape)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
                    ( OTelSignals
                        { otelTracerProvider :: TracerProvider
otelTracerProvider = TracerProvider
tracerProvider
                        , otelMeterProvider :: MeterProvider
otelMeterProvider = MeterProvider
meterProvider
                        , otelLoggerProvider :: LoggerProvider
otelLoggerProvider = LoggerProvider
loggerProvider
                        , otelPropagators :: TextMapPropagator
otelPropagators = TextMapPropagator
forall a. Monoid a => a
mempty
                        , otelShutdown :: IO ()
otelShutdown = IO ()
shutdown
                        }
                    , Maybe MetricScrape
scrape
                    )

{- Mirror @hs-opentelemetry-sdk@ 1.0.0.0's @initializeGlobalTracerProvider@, adding 'withEscapeHandler'
so an escaping exception never puts a request on a span. Re-diff against the SDK on a bump. -}
initializeEscapeHandledTracerProvider :: IO TracerProvider
initializeEscapeHandledTracerProvider :: IO TracerProvider
initializeEscapeHandledTracerProvider = do
    (processors, options) <- IO ([SpanProcessor], TracerProviderOptions)
getTracerProviderInitializationOptions
    setGlobalTextMapPropagator (tracerProviderOptionsPropagators options)
    provider <- createTracerProvider processors (withEscapeHandler options)
    setGlobalTracerProvider provider
    pure provider

{- Mirror @hs-opentelemetry-sdk@ 1.0.0.0's @initializeGlobalMeterProvider@, batching synchronous
records, observing the exporter's failures, and lifting the meter environment out for the scrape. -}
initializeObservedMeterProvider :: LogEnv -> ExportFailureSink -> IO (MeterProvider, Maybe MetricScrape)
initializeObservedMeterProvider :: LogEnv
-> ExportFailureSink -> IO (MeterProvider, Maybe MetricScrape)
initializeObservedMeterProvider LogEnv
logEnv ExportFailureSink
sink = do
    disabled <- String -> IO Bool
lookupBooleanEnv String
"OTEL_SDK_DISABLED"
    if disabled
        then (noopMeterProvider, Nothing) <$ setGlobalMeterProvider noopMeterProvider
        else do
            exporter <- observeMetricExporter sink <$> resolveMetricExporter
            readerOptions <- periodicMetricReaderOptionsFromEnv
            builtInResources <- detectBuiltInResources
            envResources <- mkResource . map Just <$> detectResourceAttributes
            let resources = Resource -> MaterializedResources
materializeResources (Resource -> Resource -> Resource
mergeResources Resource
envResources Resource
builtInResources)
            Exception.bracketOnError (createMeterProvider resources defaultSdkMeterProviderOptions) (\(MeterProvider
provider, SdkMeterEnv
_) -> IO ShutdownResult -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (MeterProvider -> Maybe Int -> IO ShutdownResult
shutdownMeterProvider MeterProvider
provider Maybe Int
forall a. Maybe a
Nothing)) $ \(MeterProvider
sdkProvider, SdkMeterEnv
env) -> do
                (batched, flushStep) <- (SomeException -> IO ())
-> MeterProvider -> IO (MeterProvider, IO ())
batchMeterProvider (ExportFailureSink -> SomeException -> IO ()
observeFlushFault ExportFailureSink
sink) MeterProvider
sdkProvider
                initializeMeterWorkers logEnv flushStep (forkPeriodicMetricReader env exporter readerOptions) $ \IO ()
stop -> do
                    let provider :: MeterProvider
provider = IO () -> MeterProvider -> MeterProvider
beforeShutdown IO ()
stop MeterProvider
batched
                    MeterProvider -> IO ()
forall (m :: * -> *). MonadIO m => MeterProvider -> m ()
setGlobalMeterProvider MeterProvider
provider
                    scrape <- SdkMeterEnv -> IO (Maybe MetricScrape)
metricScrapeFor SdkMeterEnv
env
                    pure (provider, scrape)

-- | Release the reader and flusher if final setup fails. The supplied stop always attempts both.
initializeMeterWorkers :: LogEnv -> IO () -> IO PeriodicMetricReaderHandle -> (IO () -> IO a) -> IO a
initializeMeterWorkers :: forall a.
LogEnv
-> IO ()
-> IO PeriodicMetricReaderHandle
-> (IO () -> IO a)
-> IO a
initializeMeterWorkers LogEnv
logEnv IO ()
flushStep IO PeriodicMetricReaderHandle
acquireReader IO () -> IO a
use = ((forall a. IO a -> IO a) -> IO a) -> IO a
forall b. ((forall a. IO a -> IO a) -> IO b) -> IO b
Exception.mask (((forall a. IO a -> IO a) -> IO a) -> IO a)
-> ((forall a. IO a -> IO a) -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \forall a. IO a -> IO a
restore -> do
    readerHandle <- IO PeriodicMetricReaderHandle
acquireReader
    -- Acquisition is masked. The flusher must remain cancellable.
    flusher <-
        asyncWithUnmask (\forall a. IO a -> IO a
unmask -> IO () -> IO ()
forall a. IO a -> IO a
unmask (Text -> LogEnv -> IO () -> IO ()
superviseBackground Text
"metric-flush" LogEnv
logEnv IO ()
flushStep))
            `Exception.onException` (stopPeriodicMetricReader readerHandle `catchAny` const pass)
    let stop = PeriodicMetricReaderHandle -> IO ()
stopPeriodicMetricReader PeriodicMetricReaderHandle
readerHandle IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
`Exception.finally` Async () -> IO ()
forall (m :: * -> *) a. MonadIO m => Async a -> m ()
cancel Async ()
flusher
    restore (use stop) `Exception.onException` (stop `catchAny` const pass)

{- Run a stop before the provider shuts down: the reader's, whose final export is the last, then the
flusher's. The order mirrors the SDK's own, so it is part of the same version-pin re-diff surface. -}
beforeShutdown :: IO () -> MeterProvider -> MeterProvider
beforeShutdown :: IO () -> MeterProvider -> MeterProvider
beforeShutdown IO ()
stop MeterProvider
provider =
    MeterProvider
provider{meterProviderShutdown = \Maybe Int
timeout -> IO ()
stop IO () -> IO ShutdownResult -> IO ShutdownResult
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> MeterProvider -> Maybe Int -> IO ShutdownResult
meterProviderShutdown MeterProvider
provider Maybe Int
timeout}