{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}

module OpenTelemetry.Exporter.Handle (
  makeHandleExporter,
  -- $
  stdoutExporter',
  stderrExporter',
  -- $
  defaultFormatter,
) where

import Data.IORef
import qualified Data.Text.Lazy as L
import qualified Data.Text.Lazy.IO as L
import OpenTelemetry.Exporter
import OpenTelemetry.Trace.Core
import System.IO (Handle, hFlush, stderr, stdout)


makeHandleExporter :: Handle -> (ImmutableSpan -> IO L.Text) -> Exporter ImmutableSpan
makeHandleExporter :: Handle -> (ImmutableSpan -> IO Text) -> Exporter ImmutableSpan
makeHandleExporter Handle
h ImmutableSpan -> IO Text
f =
  Exporter
    { exporterExport :: HashMap InstrumentationLibrary (Vector ImmutableSpan)
-> IO ExportResult
exporterExport = \HashMap InstrumentationLibrary (Vector ImmutableSpan)
fs -> do
        forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ImmutableSpan
s -> ImmutableSpan -> IO Text
f ImmutableSpan
s forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Handle -> Text -> IO ()
L.hPutStrLn Handle
h forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Handle -> IO ()
hFlush Handle
h)) HashMap InstrumentationLibrary (Vector ImmutableSpan)
fs
        forall (f :: * -> *) a. Applicative f => a -> f a
pure ExportResult
Success
    , exporterShutdown :: IO ()
exporterShutdown = Handle -> IO ()
hFlush Handle
h
    }


stdoutExporter' :: (ImmutableSpan -> IO L.Text) -> Exporter ImmutableSpan
stdoutExporter' :: (ImmutableSpan -> IO Text) -> Exporter ImmutableSpan
stdoutExporter' = Handle -> (ImmutableSpan -> IO Text) -> Exporter ImmutableSpan
makeHandleExporter Handle
stdout


stderrExporter' :: (ImmutableSpan -> IO L.Text) -> Exporter ImmutableSpan
stderrExporter' :: (ImmutableSpan -> IO Text) -> Exporter ImmutableSpan
stderrExporter' = Handle -> (ImmutableSpan -> IO Text) -> Exporter ImmutableSpan
makeHandleExporter Handle
stderr


defaultFormatter :: ImmutableSpan -> L.Text
defaultFormatter :: ImmutableSpan -> Text
defaultFormatter ImmutableSpan {Maybe Span
Maybe Timestamp
Text
Tracer
SpanKind
SpanStatus
SpanContext
AppendOnlyBoundedCollection Event
FrozenBoundedCollection Link
Timestamp
Attributes
spanName :: ImmutableSpan -> Text
spanParent :: ImmutableSpan -> Maybe Span
spanContext :: ImmutableSpan -> SpanContext
spanKind :: ImmutableSpan -> SpanKind
spanStart :: ImmutableSpan -> Timestamp
spanEnd :: ImmutableSpan -> Maybe Timestamp
spanAttributes :: ImmutableSpan -> Attributes
spanLinks :: ImmutableSpan -> FrozenBoundedCollection Link
spanEvents :: ImmutableSpan -> AppendOnlyBoundedCollection Event
spanStatus :: ImmutableSpan -> SpanStatus
spanTracer :: ImmutableSpan -> Tracer
spanTracer :: Tracer
spanStatus :: SpanStatus
spanEvents :: AppendOnlyBoundedCollection Event
spanLinks :: FrozenBoundedCollection Link
spanAttributes :: Attributes
spanEnd :: Maybe Timestamp
spanStart :: Timestamp
spanKind :: SpanKind
spanContext :: SpanContext
spanParent :: Maybe Span
spanName :: Text
..} =
  Text -> [Text] -> Text
L.intercalate
    Text
" "
    [ String -> Text
L.pack forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ SpanContext -> TraceId
traceId SpanContext
spanContext
    , String -> Text
L.pack forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ SpanContext -> SpanId
spanId SpanContext
spanContext
    , String -> Text
L.pack forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Timestamp
spanStart
    , Text -> Text
L.fromStrict Text
spanName
    ]