{-# LANGUAGE DeriveGeneric #-}
{-|
Module      : Instana.SDK.Span.ExitSpan
Description : An exit span
-}
module Instana.SDK.Span.ExitSpan
  ( ExitSpan(..)
  , parentId
  , traceId
  , addAnnotation
  , addToErrorCount
  , setServiceName
  , setW3cTraceContext
  , spanName
  ) where


import           Data.Text                            (Text)
import           GHC.Generics

import           Instana.SDK.Internal.Id              (Id)
import           Instana.SDK.Internal.W3CTraceContext (W3CTraceContext)
import           Instana.SDK.Span.EntrySpan           (EntrySpan)
import qualified Instana.SDK.Span.EntrySpan           as EntrySpan
import           Instana.SDK.Span.SpanData            (Annotation, SpanData)
import qualified Instana.SDK.Span.SpanData            as SpanData
import           Instana.SDK.Span.SpanType            (SpanType)
import qualified Instana.SDK.Span.SpanType            as SpanType


-- |An exit span.
data ExitSpan  =
  ExitSpan
    {
      -- |The parent span
      ExitSpan -> EntrySpan
parentSpan      :: EntrySpan
      -- |The span ID
    , ExitSpan -> Id
spanId          :: Id
      -- |The type of the span (SDK span or registerd span)
    , ExitSpan -> SpanType
spanType        :: SpanType
      -- |The time the span started
    , ExitSpan -> Int
timestamp       :: Int
      -- |An attribute for overriding the name of the service in Instana
    , ExitSpan -> Maybe Text
serviceName     :: Maybe Text
      -- |The number of errors that occured during processing
    , ExitSpan -> Int
errorCount      :: Int
      -- |Additional data for the span.
    , ExitSpan -> SpanData
spanData        :: SpanData
      -- |The W3C Trace Context. An entry span only has an associated W3C trace
      -- context, if W3C trace context headers have been received. In contrast,
      -- spans always have an associated W3C trace context.
    , ExitSpan -> W3CTraceContext
w3cTraceContext :: W3CTraceContext
    } deriving (ExitSpan -> ExitSpan -> Bool
(ExitSpan -> ExitSpan -> Bool)
-> (ExitSpan -> ExitSpan -> Bool) -> Eq ExitSpan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExitSpan -> ExitSpan -> Bool
$c/= :: ExitSpan -> ExitSpan -> Bool
== :: ExitSpan -> ExitSpan -> Bool
$c== :: ExitSpan -> ExitSpan -> Bool
Eq, (forall x. ExitSpan -> Rep ExitSpan x)
-> (forall x. Rep ExitSpan x -> ExitSpan) -> Generic ExitSpan
forall x. Rep ExitSpan x -> ExitSpan
forall x. ExitSpan -> Rep ExitSpan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExitSpan x -> ExitSpan
$cfrom :: forall x. ExitSpan -> Rep ExitSpan x
Generic, Int -> ExitSpan -> ShowS
[ExitSpan] -> ShowS
ExitSpan -> String
(Int -> ExitSpan -> ShowS)
-> (ExitSpan -> String) -> ([ExitSpan] -> ShowS) -> Show ExitSpan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExitSpan] -> ShowS
$cshowList :: [ExitSpan] -> ShowS
show :: ExitSpan -> String
$cshow :: ExitSpan -> String
showsPrec :: Int -> ExitSpan -> ShowS
$cshowsPrec :: Int -> ExitSpan -> ShowS
Show)


-- |The span name/type, e.g. a short string like "haskell.wai.server",
-- "haskell.http.client". For SDK spans this is always "sdk", the actual
-- name is then in span.data.sdk.name.
spanName :: ExitSpan -> Text
spanName :: ExitSpan -> Text
spanName = SpanType -> Text
SpanType.spanName (SpanType -> Text) -> (ExitSpan -> SpanType) -> ExitSpan -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExitSpan -> SpanType
spanType


-- |Accessor for the trace ID.
traceId :: ExitSpan -> Id
traceId :: ExitSpan -> Id
traceId exitSpan :: ExitSpan
exitSpan =
  EntrySpan -> Id
EntrySpan.traceId (EntrySpan -> Id) -> EntrySpan -> Id
forall a b. (a -> b) -> a -> b
$ ExitSpan -> EntrySpan
parentSpan ExitSpan
exitSpan


-- |Parent span ID.
parentId :: ExitSpan -> Id
parentId :: ExitSpan -> Id
parentId exitSpan :: ExitSpan
exitSpan =
  EntrySpan -> Id
EntrySpan.spanId (EntrySpan -> Id) -> EntrySpan -> Id
forall a b. (a -> b) -> a -> b
$ ExitSpan -> EntrySpan
parentSpan ExitSpan
exitSpan


-- |Add to the error count.
addToErrorCount :: Int -> ExitSpan -> ExitSpan
addToErrorCount :: Int -> ExitSpan -> ExitSpan
addToErrorCount increment :: Int
increment exitSpan :: ExitSpan
exitSpan =
  let
    ec :: Int
ec = ExitSpan -> Int
errorCount ExitSpan
exitSpan
  in
  ExitSpan
exitSpan { errorCount :: Int
errorCount = Int
ec Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
increment }


-- |Override the name of the service for the associated call in Instana.
setServiceName :: Text -> ExitSpan -> ExitSpan
setServiceName :: Text -> ExitSpan -> ExitSpan
setServiceName serviceName_ :: Text
serviceName_ exitSpan :: ExitSpan
exitSpan =
  ExitSpan
exitSpan { serviceName :: Maybe Text
serviceName = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
serviceName_ }


-- |Attaches a W3C trace context to the span.
setW3cTraceContext :: W3CTraceContext -> ExitSpan -> ExitSpan
setW3cTraceContext :: W3CTraceContext -> ExitSpan -> ExitSpan
setW3cTraceContext w3cTraceContext_ :: W3CTraceContext
w3cTraceContext_ exitSpan :: ExitSpan
exitSpan =
  ExitSpan
exitSpan { w3cTraceContext :: W3CTraceContext
w3cTraceContext = W3CTraceContext
w3cTraceContext_ }


-- |Add an annotation to the span's data section. For SDK spans, the annotation
-- is added to span.data.sdk.custom.tags, for registered spans it is added
-- directly to span.data.
addAnnotation :: Annotation -> ExitSpan -> ExitSpan
addAnnotation :: Annotation -> ExitSpan -> ExitSpan
addAnnotation annotation :: Annotation
annotation exitSpan :: ExitSpan
exitSpan =
  ExitSpan
exitSpan { spanData :: SpanData
spanData = Annotation -> SpanData -> SpanData
SpanData.merge Annotation
annotation (SpanData -> SpanData) -> SpanData -> SpanData
forall a b. (a -> b) -> a -> b
$ ExitSpan -> SpanData
spanData ExitSpan
exitSpan }