{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase                 #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE PatternSynonyms            #-}
{-# LANGUAGE RankNTypes                 #-}
{-# LANGUAGE StrictData                 #-}
{-# LANGUAGE TupleSections              #-}
{-# LANGUAGE ViewPatterns               #-}

module OpenTracing.Tags
    ( Tags(fromTags)
    , Tag
    , TagVal(..)
    , setTag
    , getTag
    , getTagReify

    -- * Standard span tags.
    -- | Refer to the [OpenTracing spec](https://github.com/opentracing/specification/blob/master/semantic_conventions.md#span-tags-table)
    -- for more info.
    , pattern ComponentKey
    , pattern DbInstanceKey
    , pattern DbStatementKey
    , pattern DbTypeKey
    , pattern DbUserKey
    , pattern ErrorKey
    , pattern HttpMethodKey
    , pattern HttpStatusCodeKey
    , pattern HttpUrlKey
    , pattern MessageBusDestinationKey
    , pattern PeerAddressKey
    , pattern PeerHostnameKey
    , pattern PeerIPv4Key
    , pattern PeerIPv6Key
    , pattern PeerPortKey
    , pattern PeerServiceKey
    , pattern SamplingPriorityKey
    , pattern SpanKindKey

    , pattern Component
    , pattern DbInstance
    , pattern DbStatement
    , pattern DbType
    , pattern DbUser
    , pattern Error
    , pattern HttpMethod
    , pattern HttpStatusCode
    , pattern HttpUrl
    , pattern MessageBusDestination
    , pattern PeerAddress
    , pattern PeerHostname
    , pattern PeerIPv4
    , pattern PeerIPv6
    , pattern PeerPort
    , pattern PeerService
    , pattern SamplingPriority
    , pattern SpanKind

    , _Component
    , _DbInstance
    , _DbStatement
    , _DbType
    , _DbUser
    , _Error
    , _HttpMethod
    , _HttpStatusCode
    , _HttpUrl
    , _MessageBusDestination
    , _PeerAddress
    , _PeerHostname
    , _PeerIPv4
    , _PeerIPv6
    , _PeerPort
    , _PeerService
    , _SamplingPriority
    , _SpanKind

    , SpanKinds(..)
    , spanKindLabel
    )
where

import           Control.Lens
import           Data.Aeson                  (ToJSON (..))
import           Data.Aeson.Encoding
import qualified Data.ByteString.Base64.Lazy as B64
import qualified Data.ByteString.Lazy        as Lazy
import           Data.HashMap.Strict         (HashMap)
import qualified Data.HashMap.Strict         as HashMap
import           Data.Int                    (Int64)
import           Data.Monoid                 (First)
import           Data.String                 (IsString)
import           Data.Text                   (Text)
import qualified Data.Text                   as Text
import           Data.Text.Encoding          (decodeUtf8, encodeUtf8)
import qualified Data.Text.Lazy.Encoding     as Lazy
import           Data.Word                   (Word8)
import           Network.HTTP.Types
import           OpenTracing.Types
import           Text.Read                   (readMaybe)

-- | Tags are structured data associated with a `OpenTracing.Span.Span`. They can give
-- a more complete picture of what a Span is doing than the operation alone. Tags
-- apply to the entire timerange of a Span. Use `OpenTracing.Log.LogField` for
-- events that refer to particular timestamp.
newtype Tags = Tags { Tags -> HashMap Text TagVal
fromTags :: HashMap Text TagVal }
    deriving (Tags -> Tags -> Bool
(Tags -> Tags -> Bool) -> (Tags -> Tags -> Bool) -> Eq Tags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tags -> Tags -> Bool
== :: Tags -> Tags -> Bool
$c/= :: Tags -> Tags -> Bool
/= :: Tags -> Tags -> Bool
Eq, Int -> Tags -> ShowS
[Tags] -> ShowS
Tags -> String
(Int -> Tags -> ShowS)
-> (Tags -> String) -> ([Tags] -> ShowS) -> Show Tags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tags -> ShowS
showsPrec :: Int -> Tags -> ShowS
$cshow :: Tags -> String
show :: Tags -> String
$cshowList :: [Tags] -> ShowS
showList :: [Tags] -> ShowS
Show, NonEmpty Tags -> Tags
Tags -> Tags -> Tags
(Tags -> Tags -> Tags)
-> (NonEmpty Tags -> Tags)
-> (forall b. Integral b => b -> Tags -> Tags)
-> Semigroup Tags
forall b. Integral b => b -> Tags -> Tags
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: Tags -> Tags -> Tags
<> :: Tags -> Tags -> Tags
$csconcat :: NonEmpty Tags -> Tags
sconcat :: NonEmpty Tags -> Tags
$cstimes :: forall b. Integral b => b -> Tags -> Tags
stimes :: forall b. Integral b => b -> Tags -> Tags
Semigroup, Semigroup Tags
Tags
Semigroup Tags =>
Tags -> (Tags -> Tags -> Tags) -> ([Tags] -> Tags) -> Monoid Tags
[Tags] -> Tags
Tags -> Tags -> Tags
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: Tags
mempty :: Tags
$cmappend :: Tags -> Tags -> Tags
mappend :: Tags -> Tags -> Tags
$cmconcat :: [Tags] -> Tags
mconcat :: [Tags] -> Tags
Monoid, [Tags] -> Value
[Tags] -> Encoding
Tags -> Bool
Tags -> Value
Tags -> Encoding
(Tags -> Value)
-> (Tags -> Encoding)
-> ([Tags] -> Value)
-> ([Tags] -> Encoding)
-> (Tags -> Bool)
-> ToJSON Tags
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Tags -> Value
toJSON :: Tags -> Value
$ctoEncoding :: Tags -> Encoding
toEncoding :: Tags -> Encoding
$ctoJSONList :: [Tags] -> Value
toJSONList :: [Tags] -> Value
$ctoEncodingList :: [Tags] -> Encoding
toEncodingList :: [Tags] -> Encoding
$comitField :: Tags -> Bool
omitField :: Tags -> Bool
ToJSON)

-- | A Tag is a key:value pair
type Tag = (Text, TagVal)

data TagVal
    = BoolT   Bool
    | StringT Text
    | IntT    Int64
    | DoubleT Double
    | BinaryT Lazy.ByteString
    deriving (TagVal -> TagVal -> Bool
(TagVal -> TagVal -> Bool)
-> (TagVal -> TagVal -> Bool) -> Eq TagVal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TagVal -> TagVal -> Bool
== :: TagVal -> TagVal -> Bool
$c/= :: TagVal -> TagVal -> Bool
/= :: TagVal -> TagVal -> Bool
Eq, Int -> TagVal -> ShowS
[TagVal] -> ShowS
TagVal -> String
(Int -> TagVal -> ShowS)
-> (TagVal -> String) -> ([TagVal] -> ShowS) -> Show TagVal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TagVal -> ShowS
showsPrec :: Int -> TagVal -> ShowS
$cshow :: TagVal -> String
show :: TagVal -> String
$cshowList :: [TagVal] -> ShowS
showList :: [TagVal] -> ShowS
Show)

instance ToJSON TagVal where
    toJSON :: TagVal -> Value
toJSON (BoolT   Bool
x) = Bool -> Value
forall a. ToJSON a => a -> Value
toJSON Bool
x
    toJSON (StringT Text
x) = Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
x
    toJSON (IntT    Int64
x) = Int64 -> Value
forall a. ToJSON a => a -> Value
toJSON Int64
x
    toJSON (DoubleT Double
x) = Double -> Value
forall a. ToJSON a => a -> Value
toJSON Double
x
    toJSON (BinaryT ByteString
x) = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (ByteString -> Text) -> ByteString -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
Lazy.decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
B64.encode (ByteString -> Value) -> ByteString -> Value
forall a b. (a -> b) -> a -> b
$ ByteString
x

    toEncoding :: TagVal -> Encoding
toEncoding (BoolT   Bool
x) = Bool -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding Bool
x
    toEncoding (StringT Text
x) = Text -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding Text
x
    toEncoding (IntT    Int64
x) = Int64 -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding Int64
x
    toEncoding (DoubleT Double
x) = Double -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding Double
x
    toEncoding (BinaryT ByteString
x) = Text -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding (Text -> Encoding)
-> (ByteString -> Text) -> ByteString -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
Lazy.decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
B64.encode (ByteString -> Encoding) -> ByteString -> Encoding
forall a b. (a -> b) -> a -> b
$ ByteString
x

setTag :: Tag -> Tags -> Tags
setTag :: Tag -> Tags -> Tags
setTag (Text
k,TagVal
v) = HashMap Text TagVal -> Tags
Tags (HashMap Text TagVal -> Tags)
-> (Tags -> HashMap Text TagVal) -> Tags -> Tags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal -> HashMap Text TagVal -> HashMap Text TagVal
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
HashMap.insert Text
k TagVal
v (HashMap Text TagVal -> HashMap Text TagVal)
-> (Tags -> HashMap Text TagVal) -> Tags -> HashMap Text TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tags -> HashMap Text TagVal
fromTags

getTag :: Text -> Tags -> Maybe TagVal
getTag :: Text -> Tags -> Maybe TagVal
getTag Text
k = Text -> HashMap Text TagVal -> Maybe TagVal
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HashMap.lookup Text
k (HashMap Text TagVal -> Maybe TagVal)
-> (Tags -> HashMap Text TagVal) -> Tags -> Maybe TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tags -> HashMap Text TagVal
fromTags

-- | Get a tag and attempt to convert it from a serialized format
getTagReify :: Getting (First b) Tag b -> Text -> Tags -> Maybe b
getTagReify :: forall b. Getting (First b) Tag b -> Text -> Tags -> Maybe b
getTagReify Getting (First b) Tag b
p Text
k Tags
ts = Text -> Tags -> Maybe TagVal
getTag Text
k Tags
ts Maybe TagVal -> (TagVal -> Maybe b) -> Maybe b
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Getting (First b) Tag b -> Tag -> Maybe b
forall s (m :: * -> *) a.
MonadReader s m =>
Getting (First a) s a -> m (Maybe a)
preview Getting (First b) Tag b
p (Tag -> Maybe b) -> (TagVal -> Tag) -> TagVal -> Maybe b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text
k,)

pattern
      ComponentKey
    , DbInstanceKey
    , DbStatementKey
    , DbTypeKey
    , DbUserKey
    , ErrorKey
    , HttpMethodKey
    , HttpStatusCodeKey
    , HttpUrlKey
    , MessageBusDestinationKey
    , PeerAddressKey
    , PeerHostnameKey
    , PeerIPv4Key
    , PeerIPv6Key
    , PeerPortKey
    , PeerServiceKey
    , SamplingPriorityKey
    , SpanKindKey
    :: forall a. (Eq a, IsString a) => a

pattern $mComponentKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bComponentKey :: forall a. (Eq a, IsString a) => a
ComponentKey             = "component"
pattern $mDbInstanceKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bDbInstanceKey :: forall a. (Eq a, IsString a) => a
DbInstanceKey            = "db.instance"
pattern $mDbStatementKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bDbStatementKey :: forall a. (Eq a, IsString a) => a
DbStatementKey           = "db.statement"
pattern $mDbTypeKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bDbTypeKey :: forall a. (Eq a, IsString a) => a
DbTypeKey                = "db.type"
pattern $mDbUserKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bDbUserKey :: forall a. (Eq a, IsString a) => a
DbUserKey                = "db.user"
pattern $mErrorKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bErrorKey :: forall a. (Eq a, IsString a) => a
ErrorKey                 = "error"
pattern $mHttpMethodKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bHttpMethodKey :: forall a. (Eq a, IsString a) => a
HttpMethodKey            = "http.method"
pattern $mHttpStatusCodeKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bHttpStatusCodeKey :: forall a. (Eq a, IsString a) => a
HttpStatusCodeKey        = "http.status_code"
pattern $mHttpUrlKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bHttpUrlKey :: forall a. (Eq a, IsString a) => a
HttpUrlKey               = "http.url"
pattern $mMessageBusDestinationKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bMessageBusDestinationKey :: forall a. (Eq a, IsString a) => a
MessageBusDestinationKey = "message_bus.destination"
pattern $mPeerAddressKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPeerAddressKey :: forall a. (Eq a, IsString a) => a
PeerAddressKey           = "peer.address"
pattern $mPeerHostnameKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPeerHostnameKey :: forall a. (Eq a, IsString a) => a
PeerHostnameKey          = "peer.hostname"
pattern $mPeerIPv4Key :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPeerIPv4Key :: forall a. (Eq a, IsString a) => a
PeerIPv4Key              = "peer.ipv4"
pattern $mPeerIPv6Key :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPeerIPv6Key :: forall a. (Eq a, IsString a) => a
PeerIPv6Key              = "peer.ipv6"
pattern $mPeerPortKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPeerPortKey :: forall a. (Eq a, IsString a) => a
PeerPortKey              = "peer.port"
pattern $mPeerServiceKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bPeerServiceKey :: forall a. (Eq a, IsString a) => a
PeerServiceKey           = "peer.service"
pattern $mSamplingPriorityKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bSamplingPriorityKey :: forall a. (Eq a, IsString a) => a
SamplingPriorityKey      = "sampling.priority"
pattern $mSpanKindKey :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bSpanKindKey :: forall a. (Eq a, IsString a) => a
SpanKindKey              = "span.kind"

_Component :: Prism' Tag Text
_Component :: Prism' Tag Text
_Component = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
ComponentKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
ComponentKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern Component :: Text -> Tag
pattern $mComponent :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bComponent :: Text -> Tag
Component v <- (preview _Component -> Just v) where
    Component Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_Component Text
v

_DbInstance :: Prism' Tag Text
_DbInstance :: Prism' Tag Text
_DbInstance = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
DbInstanceKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
DbInstanceKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern DbInstance :: Text -> Tag
pattern $mDbInstance :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bDbInstance :: Text -> Tag
DbInstance v <- (preview _DbInstance -> Just v) where
    DbInstance Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_DbInstance Text
v

_DbStatement :: Prism' Tag Text
_DbStatement :: Prism' Tag Text
_DbStatement = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
DbStatementKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
DbStatementKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern DbStatement :: Text -> Tag
pattern $mDbStatement :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bDbStatement :: Text -> Tag
DbStatement v <- (preview _DbStatement -> Just v) where
    DbStatement Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_DbStatement Text
v

_DbType :: Prism' Tag Text
_DbType :: Prism' Tag Text
_DbType = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
DbTypeKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
DbTypeKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern DbType :: Text -> Tag
pattern $mDbType :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bDbType :: Text -> Tag
DbType v <- (preview _DbType -> Just v) where
    DbType Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_DbType Text
v

_DbUser :: Prism' Tag Text
_DbUser :: Prism' Tag Text
_DbUser = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
DbUserKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
DbUserKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern DbUser :: Text -> Tag
pattern $mDbUser :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bDbUser :: Text -> Tag
DbUser v <- (preview _DbUser -> Just v) where
    DbUser Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_DbUser Text
v

_Error :: Prism' Tag Bool
_Error :: Prism' Tag Bool
_Error = (Bool -> Tag) -> (Tag -> Maybe Bool) -> Prism' Tag Bool
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
ErrorKey,) (TagVal -> Tag) -> (Bool -> TagVal) -> Bool -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> TagVal
BoolT) ((Tag -> Maybe Bool) -> Prism' Tag Bool)
-> (Tag -> Maybe Bool) -> Prism' Tag Bool
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, BoolT Bool
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
ErrorKey -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
v
    Tag
_ -> Maybe Bool
forall a. Maybe a
Nothing

pattern Error :: Bool -> Tag
pattern $mError :: forall {r}. Tag -> (Bool -> r) -> ((# #) -> r) -> r
$bError :: Bool -> Tag
Error v <- (preview _Error -> Just v) where
    Error Bool
v = AReview Tag Bool -> Bool -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Bool
Prism' Tag Bool
_Error Bool
v

_HttpUrl :: Prism' Tag Text
_HttpUrl :: Prism' Tag Text
_HttpUrl = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
HttpUrlKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
HttpUrlKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern HttpUrl :: Text -> Tag
pattern $mHttpUrl :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bHttpUrl :: Text -> Tag
HttpUrl v <- (preview _HttpUrl -> Just v) where
    HttpUrl Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_HttpUrl Text
v

_MessageBusDestination :: Prism' Tag Text
_MessageBusDestination :: Prism' Tag Text
_MessageBusDestination = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
MessageBusDestinationKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
MessageBusDestinationKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern MessageBusDestination :: Text -> Tag
pattern $mMessageBusDestination :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bMessageBusDestination :: Text -> Tag
MessageBusDestination v <- (preview _MessageBusDestination -> Just v) where
    MessageBusDestination Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_MessageBusDestination Text
v

_PeerAddress :: Prism' Tag Text
_PeerAddress :: Prism' Tag Text
_PeerAddress = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
PeerAddressKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
PeerAddressKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern PeerAddress :: Text -> Tag
pattern $mPeerAddress :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bPeerAddress :: Text -> Tag
PeerAddress v <- (preview _PeerAddress -> Just v) where
    PeerAddress Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_PeerAddress Text
v

_PeerHostname :: Prism' Tag Text
_PeerHostname :: Prism' Tag Text
_PeerHostname = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
PeerHostnameKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
PeerHostnameKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern PeerHostname :: Text -> Tag
pattern $mPeerHostname :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bPeerHostname :: Text -> Tag
PeerHostname v <- (preview _PeerHostname -> Just v) where
    PeerHostname Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_PeerHostname Text
v

_PeerService :: Prism' Tag Text
_PeerService :: Prism' Tag Text
_PeerService = (Text -> Tag) -> (Tag -> Maybe Text) -> Prism' Tag Text
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
PeerServiceKey,) (TagVal -> Tag) -> (Text -> TagVal) -> Text -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT) ((Tag -> Maybe Text) -> Prism' Tag Text)
-> (Tag -> Maybe Text) -> Prism' Tag Text
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
v) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
PeerServiceKey -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
v
    Tag
_ -> Maybe Text
forall a. Maybe a
Nothing

pattern PeerService :: Text -> Tag
pattern $mPeerService :: forall {r}. Tag -> (Text -> r) -> ((# #) -> r) -> r
$bPeerService :: Text -> Tag
PeerService v <- (preview _PeerService -> Just v) where
    PeerService Text
v = AReview Tag Text -> Text -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Text
Prism' Tag Text
_PeerService Text
v

_HttpMethod :: Prism' Tag Method
_HttpMethod :: Prism' Tag Method
_HttpMethod = (Method -> Tag) -> (Tag -> Maybe Method) -> Prism' Tag Method
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
HttpMethodKey,) (TagVal -> Tag) -> (Method -> TagVal) -> Method -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT (Text -> TagVal) -> (Method -> Text) -> Method -> TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Method -> Text
decodeUtf8) ((Tag -> Maybe Method) -> Prism' Tag Method)
-> (Tag -> Maybe Method) -> Prism' Tag Method
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT (Text -> Method
encodeUtf8 -> Method
x)) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
HttpMethodKey ->
        (Method -> Maybe Method)
-> (StdMethod -> Maybe Method)
-> Either Method StdMethod
-> Maybe Method
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe Method -> Method -> Maybe Method
forall a b. a -> b -> a
const Maybe Method
forall a. Maybe a
Nothing) (Maybe Method -> StdMethod -> Maybe Method
forall a b. a -> b -> a
const (Method -> Maybe Method
forall a. a -> Maybe a
Just Method
x)) (Either Method StdMethod -> Maybe Method)
-> Either Method StdMethod -> Maybe Method
forall a b. (a -> b) -> a -> b
$ Method -> Either Method StdMethod
parseMethod Method
x
    Tag
_ -> Maybe Method
forall a. Maybe a
Nothing

pattern HttpMethod :: Method -> Tag
pattern $mHttpMethod :: forall {r}. Tag -> (Method -> r) -> ((# #) -> r) -> r
$bHttpMethod :: Method -> Tag
HttpMethod v <- (preview _HttpMethod -> Just v) where
    HttpMethod Method
v = AReview Tag Method -> Method -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Method
Prism' Tag Method
_HttpMethod Method
v

_HttpStatusCode :: Prism' Tag Status
_HttpStatusCode :: Prism' Tag Status
_HttpStatusCode = (Status -> Tag) -> (Tag -> Maybe Status) -> Prism' Tag Status
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
HttpStatusCodeKey,) (TagVal -> Tag) -> (Status -> TagVal) -> Status -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> TagVal
IntT (Int64 -> TagVal) -> (Status -> Int64) -> Status -> TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int64) -> (Status -> Int) -> Status -> Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Status -> Int
statusCode) ((Tag -> Maybe Status) -> Prism' Tag Status)
-> (Tag -> Maybe Status) -> Prism' Tag Status
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, IntT Int64
x) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
HttpStatusCodeKey -> Status -> Maybe Status
forall a. a -> Maybe a
Just (Status -> Maybe Status)
-> (Int64 -> Status) -> Int64 -> Maybe Status
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Status
forall a. Enum a => Int -> a
toEnum (Int -> Status) -> (Int64 -> Int) -> Int64 -> Status
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Maybe Status) -> Int64 -> Maybe Status
forall a b. (a -> b) -> a -> b
$ Int64
x
    Tag
_ -> Maybe Status
forall a. Maybe a
Nothing

pattern HttpStatusCode :: Status -> Tag
pattern $mHttpStatusCode :: forall {r}. Tag -> (Status -> r) -> ((# #) -> r) -> r
$bHttpStatusCode :: Status -> Tag
HttpStatusCode v <- (preview _HttpStatusCode -> Just v) where
    HttpStatusCode Status
v = AReview Tag Status -> Status -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Status
Prism' Tag Status
_HttpStatusCode Status
v

_PeerIPv4 :: Prism' Tag IPv4
_PeerIPv4 :: Prism' Tag IPv4
_PeerIPv4 = (IPv4 -> Tag) -> (Tag -> Maybe IPv4) -> Prism' Tag IPv4
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
PeerIPv4Key,) (TagVal -> Tag) -> (IPv4 -> TagVal) -> IPv4 -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT (Text -> TagVal) -> (IPv4 -> Text) -> IPv4 -> TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack (String -> Text) -> (IPv4 -> String) -> IPv4 -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IPv4 -> String
forall a. Show a => a -> String
show) ((Tag -> Maybe IPv4) -> Prism' Tag IPv4)
-> (Tag -> Maybe IPv4) -> Prism' Tag IPv4
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
x) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
PeerIPv4Key -> String -> Maybe IPv4
forall a. Read a => String -> Maybe a
readMaybe (Text -> String
Text.unpack Text
x)
    Tag
_ -> Maybe IPv4
forall a. Maybe a
Nothing

pattern PeerIPv4 :: IPv4 -> Tag
pattern $mPeerIPv4 :: forall {r}. Tag -> (IPv4 -> r) -> ((# #) -> r) -> r
$bPeerIPv4 :: IPv4 -> Tag
PeerIPv4 v <- (preview _PeerIPv4 -> Just v) where
    PeerIPv4 IPv4
v = AReview Tag IPv4 -> IPv4 -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag IPv4
Prism' Tag IPv4
_PeerIPv4 IPv4
v

_PeerIPv6 :: Prism' Tag IPv6
_PeerIPv6 :: Prism' Tag IPv6
_PeerIPv6 = (IPv6 -> Tag) -> (Tag -> Maybe IPv6) -> Prism' Tag IPv6
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
PeerIPv6Key,) (TagVal -> Tag) -> (IPv6 -> TagVal) -> IPv6 -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT (Text -> TagVal) -> (IPv6 -> Text) -> IPv6 -> TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack (String -> Text) -> (IPv6 -> String) -> IPv6 -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IPv6 -> String
forall a. Show a => a -> String
show) ((Tag -> Maybe IPv6) -> Prism' Tag IPv6)
-> (Tag -> Maybe IPv6) -> Prism' Tag IPv6
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
x) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
PeerIPv6Key -> String -> Maybe IPv6
forall a. Read a => String -> Maybe a
readMaybe (Text -> String
Text.unpack Text
x)
    Tag
_ -> Maybe IPv6
forall a. Maybe a
Nothing

pattern PeerIPv6 :: IPv6 -> Tag
pattern $mPeerIPv6 :: forall {r}. Tag -> (IPv6 -> r) -> ((# #) -> r) -> r
$bPeerIPv6 :: IPv6 -> Tag
PeerIPv6 v <- (preview _PeerIPv6 -> Just v) where
    PeerIPv6 IPv6
v = AReview Tag IPv6 -> IPv6 -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag IPv6
Prism' Tag IPv6
_PeerIPv6 IPv6
v

_PeerPort :: Prism' Tag Port
_PeerPort :: Prism' Tag Port
_PeerPort = (Port -> Tag) -> (Tag -> Maybe Port) -> Prism' Tag Port
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
PeerPortKey,) (TagVal -> Tag) -> (Port -> TagVal) -> Port -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> TagVal
IntT (Int64 -> TagVal) -> (Port -> Int64) -> Port -> TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Int64) -> (Port -> Word16) -> Port -> Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Port -> Word16
fromPort) ((Tag -> Maybe Port) -> Prism' Tag Port)
-> (Tag -> Maybe Port) -> Prism' Tag Port
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, IntT Int64
x) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
PeerPortKey -> Port -> Maybe Port
forall a. a -> Maybe a
Just (Port -> Maybe Port) -> (Int64 -> Port) -> Int64 -> Maybe Port
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Port
forall a. Enum a => Int -> a
toEnum (Int -> Port) -> (Int64 -> Int) -> Int64 -> Port
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Maybe Port) -> Int64 -> Maybe Port
forall a b. (a -> b) -> a -> b
$ Int64
x
    Tag
_ -> Maybe Port
forall a. Maybe a
Nothing

pattern PeerPort :: Port -> Tag
pattern $mPeerPort :: forall {r}. Tag -> (Port -> r) -> ((# #) -> r) -> r
$bPeerPort :: Port -> Tag
PeerPort v <- (preview _PeerPort -> Just v) where
    PeerPort Port
v = AReview Tag Port -> Port -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Port
Prism' Tag Port
_PeerPort Port
v

_SamplingPriority :: Prism' Tag Word8
_SamplingPriority :: Prism' Tag Word8
_SamplingPriority = (Word8 -> Tag) -> (Tag -> Maybe Word8) -> Prism' Tag Word8
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
SamplingPriorityKey,) (TagVal -> Tag) -> (Word8 -> TagVal) -> Word8 -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> TagVal
IntT (Int64 -> TagVal) -> (Word8 -> Int64) -> Word8 -> TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral) ((Tag -> Maybe Word8) -> Prism' Tag Word8)
-> (Tag -> Maybe Word8) -> Prism' Tag Word8
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, IntT Int64
x) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
SamplingPriorityKey -> Word8 -> Maybe Word8
forall a. a -> Maybe a
Just (Word8 -> Maybe Word8) -> (Int64 -> Word8) -> Int64 -> Maybe Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Maybe Word8) -> Int64 -> Maybe Word8
forall a b. (a -> b) -> a -> b
$ Int64
x
    Tag
_ -> Maybe Word8
forall a. Maybe a
Nothing

pattern SamplingPriority :: Word8 -> Tag
pattern $mSamplingPriority :: forall {r}. Tag -> (Word8 -> r) -> ((# #) -> r) -> r
$bSamplingPriority :: Word8 -> Tag
SamplingPriority v <- (preview _SamplingPriority -> Just v) where
    SamplingPriority Word8
v = AReview Tag Word8 -> Word8 -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag Word8
Prism' Tag Word8
_SamplingPriority Word8
v

_SpanKind :: Prism' Tag SpanKinds
_SpanKind :: Prism' Tag SpanKinds
_SpanKind = (SpanKinds -> Tag)
-> (Tag -> Maybe SpanKinds) -> Prism' Tag SpanKinds
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ((Text
forall a. (Eq a, IsString a) => a
SpanKindKey,) (TagVal -> Tag) -> (SpanKinds -> TagVal) -> SpanKinds -> Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TagVal
StringT (Text -> TagVal) -> (SpanKinds -> Text) -> SpanKinds -> TagVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanKinds -> Text
spanKindLabel) ((Tag -> Maybe SpanKinds) -> Prism' Tag SpanKinds)
-> (Tag -> Maybe SpanKinds) -> Prism' Tag SpanKinds
forall a b. (a -> b) -> a -> b
$ \case
    (Text
k, StringT Text
x) | Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
forall a. (Eq a, IsString a) => a
SpanKindKey -> Text -> Maybe SpanKinds
fromSpanKindLabel Text
x
    Tag
_ -> Maybe SpanKinds
forall a. Maybe a
Nothing

pattern SpanKind :: SpanKinds -> Tag
pattern $mSpanKind :: forall {r}. Tag -> (SpanKinds -> r) -> ((# #) -> r) -> r
$bSpanKind :: SpanKinds -> Tag
SpanKind v <- (preview _SpanKind -> Just v) where
    SpanKind = AReview Tag SpanKinds -> SpanKinds -> Tag
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview Tag SpanKinds
Prism' Tag SpanKinds
_SpanKind

data SpanKinds
    = RPCClient
    | RPCServer
    | Producer
    | Consumer
    deriving (SpanKinds -> SpanKinds -> Bool
(SpanKinds -> SpanKinds -> Bool)
-> (SpanKinds -> SpanKinds -> Bool) -> Eq SpanKinds
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpanKinds -> SpanKinds -> Bool
== :: SpanKinds -> SpanKinds -> Bool
$c/= :: SpanKinds -> SpanKinds -> Bool
/= :: SpanKinds -> SpanKinds -> Bool
Eq, Int -> SpanKinds -> ShowS
[SpanKinds] -> ShowS
SpanKinds -> String
(Int -> SpanKinds -> ShowS)
-> (SpanKinds -> String)
-> ([SpanKinds] -> ShowS)
-> Show SpanKinds
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SpanKinds -> ShowS
showsPrec :: Int -> SpanKinds -> ShowS
$cshow :: SpanKinds -> String
show :: SpanKinds -> String
$cshowList :: [SpanKinds] -> ShowS
showList :: [SpanKinds] -> ShowS
Show, Eq SpanKinds
Eq SpanKinds =>
(SpanKinds -> SpanKinds -> Ordering)
-> (SpanKinds -> SpanKinds -> Bool)
-> (SpanKinds -> SpanKinds -> Bool)
-> (SpanKinds -> SpanKinds -> Bool)
-> (SpanKinds -> SpanKinds -> Bool)
-> (SpanKinds -> SpanKinds -> SpanKinds)
-> (SpanKinds -> SpanKinds -> SpanKinds)
-> Ord SpanKinds
SpanKinds -> SpanKinds -> Bool
SpanKinds -> SpanKinds -> Ordering
SpanKinds -> SpanKinds -> SpanKinds
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SpanKinds -> SpanKinds -> Ordering
compare :: SpanKinds -> SpanKinds -> Ordering
$c< :: SpanKinds -> SpanKinds -> Bool
< :: SpanKinds -> SpanKinds -> Bool
$c<= :: SpanKinds -> SpanKinds -> Bool
<= :: SpanKinds -> SpanKinds -> Bool
$c> :: SpanKinds -> SpanKinds -> Bool
> :: SpanKinds -> SpanKinds -> Bool
$c>= :: SpanKinds -> SpanKinds -> Bool
>= :: SpanKinds -> SpanKinds -> Bool
$cmax :: SpanKinds -> SpanKinds -> SpanKinds
max :: SpanKinds -> SpanKinds -> SpanKinds
$cmin :: SpanKinds -> SpanKinds -> SpanKinds
min :: SpanKinds -> SpanKinds -> SpanKinds
Ord)

spanKindLabel :: SpanKinds -> Text
spanKindLabel :: SpanKinds -> Text
spanKindLabel SpanKinds
RPCClient = Text
"CLIENT"
spanKindLabel SpanKinds
RPCServer = Text
"SERVER"
spanKindLabel SpanKinds
Producer  = Text
"PRODUCER"
spanKindLabel SpanKinds
Consumer  = Text
"CONSUMER"

fromSpanKindLabel :: Text -> Maybe SpanKinds
fromSpanKindLabel :: Text -> Maybe SpanKinds
fromSpanKindLabel Text
"CLIENT"   = SpanKinds -> Maybe SpanKinds
forall a. a -> Maybe a
Just SpanKinds
RPCClient
fromSpanKindLabel Text
"SERVER"   = SpanKinds -> Maybe SpanKinds
forall a. a -> Maybe a
Just SpanKinds
RPCServer
fromSpanKindLabel Text
"PRODUCER" = SpanKinds -> Maybe SpanKinds
forall a. a -> Maybe a
Just SpanKinds
Producer
fromSpanKindLabel Text
"CONSUMER" = SpanKinds -> Maybe SpanKinds
forall a. a -> Maybe a
Just SpanKinds
Consumer
fromSpanKindLabel Text
_          = Maybe SpanKinds
forall a. Maybe a
Nothing

instance ToJSON SpanKinds where
    toJSON :: SpanKinds -> Value
toJSON     = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (SpanKinds -> Text) -> SpanKinds -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanKinds -> Text
spanKindLabel
    toEncoding :: SpanKinds -> Encoding
toEncoding = Text -> Encoding
forall a. Text -> Encoding' a
text   (Text -> Encoding) -> (SpanKinds -> Text) -> SpanKinds -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanKinds -> Text
spanKindLabel