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

{- | The bounded-label discipline for the @ecluse.*@ metrics. An inline proxy sees thousands of
distinct packages, so one high-cardinality label turns a handful of series into millions.
'Label' is a closed sum over bounded-domain keys and values: @package@, @version@, @scope@, and
a denial @message@ have no constructor, so the type keeps them off a metric, and they ride the
spans and the log line instead. @rule@ is the exception, bounded by a deployment's own rule set
rather than by an enum. The instruments these label are in
"Ecluse.Core.Telemetry.Catalogue".
-}
module Ecluse.Core.Telemetry.Metrics (
    -- * Label keys (the closed set)
    LabelKey (..),
    labelKeyName,

    -- * Bounded label values
    Decision (..),
    ReasonClass (..),
    Upstream (..),
    StatusClass (..),
    Provider (..),
    Cause (..),
    Tier (..),
    CacheResult (..),
    CacheStore (..),
    MirrorResult (..),
    SweepResult (..),
    SweepTarget (..),
    CredentialResult (..),
    AdvisorySyncResult (..),
    advisorySyncResultName,
    AdvisoryDropCause (..),
    AdvisoryCompileResult (..),
    BreakerSource (..),
    RequestFaultCause (..),
    RelayAnomaly (..),

    -- * Breaker state (a bounded gauge value, not a label)
    BreakerState (..),
    breakerStateCode,

    -- * Labels
    Label (..),
    labelKey,
    renderLabel,

    -- * Attribute construction
    metricAttributes,
) where

-- relude's prelude exports a Bounded/Enum-based `universe`. Hide it so the
-- Generic-derived `Data.Universe.Class.universe` is the one in scope here.
import Prelude hiding (universe)

import OpenTelemetry.Attributes (
    Attributes,
    addAttributesFromBuilder,
    attr,
    defaultAttributeLimits,
    emptyAttributes,
 )

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

import Ecluse.Core.Ecosystem (Ecosystem, ecosystemName)

{- | The closed set of metric label keys. The high-cardinality identifiers (@package@,
@version@, @scope@, a denial @message@) have no key, so they can never become a label.
-}
data LabelKey
    = KeyDecision
    | KeyReasonClass
    | KeyRule
    | KeyEcosystem
    | KeyMount
    | KeyUpstream
    | KeyStatusClass
    | KeyResult
    | KeyTarget
    | KeyProvider
    | KeyCause
    | KeyBreakerSource
    | KeyTier
    | KeyStore
    deriving stock (LabelKey -> LabelKey -> Bool
(LabelKey -> LabelKey -> Bool)
-> (LabelKey -> LabelKey -> Bool) -> Eq LabelKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LabelKey -> LabelKey -> Bool
== :: LabelKey -> LabelKey -> Bool
$c/= :: LabelKey -> LabelKey -> Bool
/= :: LabelKey -> LabelKey -> Bool
Eq, (forall x. LabelKey -> Rep LabelKey x)
-> (forall x. Rep LabelKey x -> LabelKey) -> Generic LabelKey
forall x. Rep LabelKey x -> LabelKey
forall x. LabelKey -> Rep LabelKey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LabelKey -> Rep LabelKey x
from :: forall x. LabelKey -> Rep LabelKey x
$cto :: forall x. Rep LabelKey x -> LabelKey
to :: forall x. Rep LabelKey x -> LabelKey
Generic, Eq LabelKey
Eq LabelKey =>
(LabelKey -> LabelKey -> Ordering)
-> (LabelKey -> LabelKey -> Bool)
-> (LabelKey -> LabelKey -> Bool)
-> (LabelKey -> LabelKey -> Bool)
-> (LabelKey -> LabelKey -> Bool)
-> (LabelKey -> LabelKey -> LabelKey)
-> (LabelKey -> LabelKey -> LabelKey)
-> Ord LabelKey
LabelKey -> LabelKey -> Bool
LabelKey -> LabelKey -> Ordering
LabelKey -> LabelKey -> LabelKey
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 :: LabelKey -> LabelKey -> Ordering
compare :: LabelKey -> LabelKey -> Ordering
$c< :: LabelKey -> LabelKey -> Bool
< :: LabelKey -> LabelKey -> Bool
$c<= :: LabelKey -> LabelKey -> Bool
<= :: LabelKey -> LabelKey -> Bool
$c> :: LabelKey -> LabelKey -> Bool
> :: LabelKey -> LabelKey -> Bool
$c>= :: LabelKey -> LabelKey -> Bool
>= :: LabelKey -> LabelKey -> Bool
$cmax :: LabelKey -> LabelKey -> LabelKey
max :: LabelKey -> LabelKey -> LabelKey
$cmin :: LabelKey -> LabelKey -> LabelKey
min :: LabelKey -> LabelKey -> LabelKey
Ord, Int -> LabelKey -> ShowS
[LabelKey] -> ShowS
LabelKey -> String
(Int -> LabelKey -> ShowS)
-> (LabelKey -> String) -> ([LabelKey] -> ShowS) -> Show LabelKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LabelKey -> ShowS
showsPrec :: Int -> LabelKey -> ShowS
$cshow :: LabelKey -> String
show :: LabelKey -> String
$cshowList :: [LabelKey] -> ShowS
showList :: [LabelKey] -> ShowS
Show)

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

-- | The wire name of a 'LabelKey'.
labelKeyName :: LabelKey -> Text
labelKeyName :: LabelKey -> Text
labelKeyName = \case
    LabelKey
KeyDecision -> Text
"decision"
    LabelKey
KeyReasonClass -> Text
"reason_class"
    LabelKey
KeyRule -> Text
"rule"
    LabelKey
KeyEcosystem -> Text
"ecosystem"
    LabelKey
KeyMount -> Text
"mount"
    LabelKey
KeyUpstream -> Text
"upstream"
    LabelKey
KeyStatusClass -> Text
"status_class"
    LabelKey
KeyResult -> Text
"result"
    LabelKey
KeyTarget -> Text
"target"
    LabelKey
KeyProvider -> Text
"provider"
    LabelKey
KeyCause -> Text
"cause"
    LabelKey
KeyBreakerSource -> Text
"source"
    LabelKey
KeyTier -> Text
"tier"
    LabelKey
KeyStore -> Text
"store"

-- | The serve decision (@ecluse.serve.decision@).
data Decision = Admit | Deny | Unavailable
    deriving stock (Decision -> Decision -> Bool
(Decision -> Decision -> Bool)
-> (Decision -> Decision -> Bool) -> Eq Decision
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decision -> Decision -> Bool
== :: Decision -> Decision -> Bool
$c/= :: Decision -> Decision -> Bool
/= :: Decision -> Decision -> Bool
Eq, (forall x. Decision -> Rep Decision x)
-> (forall x. Rep Decision x -> Decision) -> Generic Decision
forall x. Rep Decision x -> Decision
forall x. Decision -> Rep Decision x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Decision -> Rep Decision x
from :: forall x. Decision -> Rep Decision x
$cto :: forall x. Rep Decision x -> Decision
to :: forall x. Rep Decision x -> Decision
Generic, Int -> Decision -> ShowS
[Decision] -> ShowS
Decision -> String
(Int -> Decision -> ShowS)
-> (Decision -> String) -> ([Decision] -> ShowS) -> Show Decision
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Decision -> ShowS
showsPrec :: Int -> Decision -> ShowS
$cshow :: Decision -> String
show :: Decision -> String
$cshowList :: [Decision] -> ShowS
showList :: [Decision] -> ShowS
Show)

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

{- | The bucketed class of a denial reason. Not the rule name or the message, which are
high-cardinality and stay on the log line.
-}
data ReasonClass = ReasonPolicy | ReasonMissingIntegrity | ReasonUnavailable | ReasonLimit
    deriving stock (ReasonClass -> ReasonClass -> Bool
(ReasonClass -> ReasonClass -> Bool)
-> (ReasonClass -> ReasonClass -> Bool) -> Eq ReasonClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReasonClass -> ReasonClass -> Bool
== :: ReasonClass -> ReasonClass -> Bool
$c/= :: ReasonClass -> ReasonClass -> Bool
/= :: ReasonClass -> ReasonClass -> Bool
Eq, (forall x. ReasonClass -> Rep ReasonClass x)
-> (forall x. Rep ReasonClass x -> ReasonClass)
-> Generic ReasonClass
forall x. Rep ReasonClass x -> ReasonClass
forall x. ReasonClass -> Rep ReasonClass x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ReasonClass -> Rep ReasonClass x
from :: forall x. ReasonClass -> Rep ReasonClass x
$cto :: forall x. Rep ReasonClass x -> ReasonClass
to :: forall x. Rep ReasonClass x -> ReasonClass
Generic, Int -> ReasonClass -> ShowS
[ReasonClass] -> ShowS
ReasonClass -> String
(Int -> ReasonClass -> ShowS)
-> (ReasonClass -> String)
-> ([ReasonClass] -> ShowS)
-> Show ReasonClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReasonClass -> ShowS
showsPrec :: Int -> ReasonClass -> ShowS
$cshow :: ReasonClass -> String
show :: ReasonClass -> String
$cshowList :: [ReasonClass] -> ShowS
showList :: [ReasonClass] -> ShowS
Show)

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

-- | Which upstream a data-plane fetch targeted.
data Upstream = Private | Public
    deriving stock (Upstream -> Upstream -> Bool
(Upstream -> Upstream -> Bool)
-> (Upstream -> Upstream -> Bool) -> Eq Upstream
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Upstream -> Upstream -> Bool
== :: Upstream -> Upstream -> Bool
$c/= :: Upstream -> Upstream -> Bool
/= :: Upstream -> Upstream -> Bool
Eq, (forall x. Upstream -> Rep Upstream x)
-> (forall x. Rep Upstream x -> Upstream) -> Generic Upstream
forall x. Rep Upstream x -> Upstream
forall x. Upstream -> Rep Upstream x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Upstream -> Rep Upstream x
from :: forall x. Upstream -> Rep Upstream x
$cto :: forall x. Rep Upstream x -> Upstream
to :: forall x. Rep Upstream x -> Upstream
Generic, Int -> Upstream -> ShowS
[Upstream] -> ShowS
Upstream -> String
(Int -> Upstream -> ShowS)
-> (Upstream -> String) -> ([Upstream] -> ShowS) -> Show Upstream
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Upstream -> ShowS
showsPrec :: Int -> Upstream -> ShowS
$cshow :: Upstream -> String
show :: Upstream -> String
$cshowList :: [Upstream] -> ShowS
showList :: [Upstream] -> ShowS
Show)

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

-- | The HTTP status class of an upstream response (the bounded summary of the code).
data StatusClass = Status2xx | Status3xx | Status4xx | Status5xx | StatusOther
    deriving stock (StatusClass -> StatusClass -> Bool
(StatusClass -> StatusClass -> Bool)
-> (StatusClass -> StatusClass -> Bool) -> Eq StatusClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusClass -> StatusClass -> Bool
== :: StatusClass -> StatusClass -> Bool
$c/= :: StatusClass -> StatusClass -> Bool
/= :: StatusClass -> StatusClass -> Bool
Eq, (forall x. StatusClass -> Rep StatusClass x)
-> (forall x. Rep StatusClass x -> StatusClass)
-> Generic StatusClass
forall x. Rep StatusClass x -> StatusClass
forall x. StatusClass -> Rep StatusClass x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StatusClass -> Rep StatusClass x
from :: forall x. StatusClass -> Rep StatusClass x
$cto :: forall x. Rep StatusClass x -> StatusClass
to :: forall x. Rep StatusClass x -> StatusClass
Generic, Int -> StatusClass -> ShowS
[StatusClass] -> ShowS
StatusClass -> String
(Int -> StatusClass -> ShowS)
-> (StatusClass -> String)
-> ([StatusClass] -> ShowS)
-> Show StatusClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusClass -> ShowS
showsPrec :: Int -> StatusClass -> ShowS
$cshow :: StatusClass -> String
show :: StatusClass -> String
$cshowList :: [StatusClass] -> ShowS
showList :: [StatusClass] -> ShowS
Show)

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

{- | The store a mirror-write credential's refresh\/ttl signal concerns: one value per store
tag the configuration admits, so a dashboard and a mount's declaration spell the same word.
-}
data Provider = ProviderRegistry | ProviderCodeArtifact | ProviderVerdaccio
    deriving stock (Provider -> Provider -> Bool
(Provider -> Provider -> Bool)
-> (Provider -> Provider -> Bool) -> Eq Provider
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Provider -> Provider -> Bool
== :: Provider -> Provider -> Bool
$c/= :: Provider -> Provider -> Bool
/= :: Provider -> Provider -> Bool
Eq, (forall x. Provider -> Rep Provider x)
-> (forall x. Rep Provider x -> Provider) -> Generic Provider
forall x. Rep Provider x -> Provider
forall x. Provider -> Rep Provider x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Provider -> Rep Provider x
from :: forall x. Provider -> Rep Provider x
$cto :: forall x. Rep Provider x -> Provider
to :: forall x. Rep Provider x -> Provider
Generic, Int -> Provider -> ShowS
[Provider] -> ShowS
Provider -> String
(Int -> Provider -> ShowS)
-> (Provider -> String) -> ([Provider] -> ShowS) -> Show Provider
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Provider -> ShowS
showsPrec :: Int -> Provider -> ShowS
$cshow :: Provider -> String
show :: Provider -> String
$cshowList :: [Provider] -> ShowS
showList :: [Provider] -> ShowS
Show)

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

-- | A bounded error class for a failure signal (never the exception text).
data Cause = Timeout | Connection | Decode | UpstreamStatus | OtherCause
    deriving stock (Cause -> Cause -> Bool
(Cause -> Cause -> Bool) -> (Cause -> Cause -> Bool) -> Eq Cause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Cause -> Cause -> Bool
== :: Cause -> Cause -> Bool
$c/= :: Cause -> Cause -> Bool
/= :: Cause -> Cause -> Bool
Eq, (forall x. Cause -> Rep Cause x)
-> (forall x. Rep Cause x -> Cause) -> Generic Cause
forall x. Rep Cause x -> Cause
forall x. Cause -> Rep Cause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Cause -> Rep Cause x
from :: forall x. Cause -> Rep Cause x
$cto :: forall x. Rep Cause x -> Cause
to :: forall x. Rep Cause x -> Cause
Generic, Int -> Cause -> ShowS
[Cause] -> ShowS
Cause -> String
(Int -> Cause -> ShowS)
-> (Cause -> String) -> ([Cause] -> ShowS) -> Show Cause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Cause -> ShowS
showsPrec :: Int -> Cause -> ShowS
$cshow :: Cause -> String
show :: Cause -> String
$cshowList :: [Cause] -> ShowS
showList :: [Cause] -> ShowS
Show)

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

-- | The rule-evaluation tier a duration is measured at.
data Tier = Structural | Effectful
    deriving stock (Tier -> Tier -> Bool
(Tier -> Tier -> Bool) -> (Tier -> Tier -> Bool) -> Eq Tier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tier -> Tier -> Bool
== :: Tier -> Tier -> Bool
$c/= :: Tier -> Tier -> Bool
/= :: Tier -> Tier -> Bool
Eq, (forall x. Tier -> Rep Tier x)
-> (forall x. Rep Tier x -> Tier) -> Generic Tier
forall x. Rep Tier x -> Tier
forall x. Tier -> Rep Tier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Tier -> Rep Tier x
from :: forall x. Tier -> Rep Tier x
$cto :: forall x. Rep Tier x -> Tier
to :: forall x. Rep Tier x -> Tier
Generic, Int -> Tier -> ShowS
[Tier] -> ShowS
Tier -> String
(Int -> Tier -> ShowS)
-> (Tier -> String) -> ([Tier] -> ShowS) -> Show Tier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tier -> ShowS
showsPrec :: Int -> Tier -> ShowS
$cshow :: Tier -> String
show :: Tier -> String
$cshowList :: [Tier] -> ShowS
showList :: [Tier] -> ShowS
Show)

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

{- | Why the request perimeter had to answer for an escaped fault. The unbounded detail rides
the perimeter's log line, never a label.
-}
data RequestFaultCause = RenderFault | UnclassifiedFault
    deriving stock (RequestFaultCause -> RequestFaultCause -> Bool
(RequestFaultCause -> RequestFaultCause -> Bool)
-> (RequestFaultCause -> RequestFaultCause -> Bool)
-> Eq RequestFaultCause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestFaultCause -> RequestFaultCause -> Bool
== :: RequestFaultCause -> RequestFaultCause -> Bool
$c/= :: RequestFaultCause -> RequestFaultCause -> Bool
/= :: RequestFaultCause -> RequestFaultCause -> Bool
Eq, (forall x. RequestFaultCause -> Rep RequestFaultCause x)
-> (forall x. Rep RequestFaultCause x -> RequestFaultCause)
-> Generic RequestFaultCause
forall x. Rep RequestFaultCause x -> RequestFaultCause
forall x. RequestFaultCause -> Rep RequestFaultCause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RequestFaultCause -> Rep RequestFaultCause x
from :: forall x. RequestFaultCause -> Rep RequestFaultCause x
$cto :: forall x. Rep RequestFaultCause x -> RequestFaultCause
to :: forall x. Rep RequestFaultCause x -> RequestFaultCause
Generic, Int -> RequestFaultCause -> ShowS
[RequestFaultCause] -> ShowS
RequestFaultCause -> String
(Int -> RequestFaultCause -> ShowS)
-> (RequestFaultCause -> String)
-> ([RequestFaultCause] -> ShowS)
-> Show RequestFaultCause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RequestFaultCause -> ShowS
showsPrec :: Int -> RequestFaultCause -> ShowS
$cshow :: RequestFaultCause -> String
show :: RequestFaultCause -> String
$cshowList :: [RequestFaultCause] -> ShowS
showList :: [RequestFaultCause] -> ShowS
Show)

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

{- | What a public artifact relay passed through when it did not carry the admitted artifact:
a 2xx that does not look like one, or a non-success relayed verbatim.
-}
data RelayAnomaly = RelayOddShape | RelayNonSuccess
    deriving stock (RelayAnomaly -> RelayAnomaly -> Bool
(RelayAnomaly -> RelayAnomaly -> Bool)
-> (RelayAnomaly -> RelayAnomaly -> Bool) -> Eq RelayAnomaly
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelayAnomaly -> RelayAnomaly -> Bool
== :: RelayAnomaly -> RelayAnomaly -> Bool
$c/= :: RelayAnomaly -> RelayAnomaly -> Bool
/= :: RelayAnomaly -> RelayAnomaly -> Bool
Eq, (forall x. RelayAnomaly -> Rep RelayAnomaly x)
-> (forall x. Rep RelayAnomaly x -> RelayAnomaly)
-> Generic RelayAnomaly
forall x. Rep RelayAnomaly x -> RelayAnomaly
forall x. RelayAnomaly -> Rep RelayAnomaly x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RelayAnomaly -> Rep RelayAnomaly x
from :: forall x. RelayAnomaly -> Rep RelayAnomaly x
$cto :: forall x. Rep RelayAnomaly x -> RelayAnomaly
to :: forall x. Rep RelayAnomaly x -> RelayAnomaly
Generic, Int -> RelayAnomaly -> ShowS
[RelayAnomaly] -> ShowS
RelayAnomaly -> String
(Int -> RelayAnomaly -> ShowS)
-> (RelayAnomaly -> String)
-> ([RelayAnomaly] -> ShowS)
-> Show RelayAnomaly
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelayAnomaly -> ShowS
showsPrec :: Int -> RelayAnomaly -> ShowS
$cshow :: RelayAnomaly -> String
show :: RelayAnomaly -> String
$cshowList :: [RelayAnomaly] -> ShowS
showList :: [RelayAnomaly] -> ShowS
Show)

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

-- | A metadata-cache lookup result.
data CacheResult = Hit | Miss | Collapsed
    deriving stock (CacheResult -> CacheResult -> Bool
(CacheResult -> CacheResult -> Bool)
-> (CacheResult -> CacheResult -> Bool) -> Eq CacheResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CacheResult -> CacheResult -> Bool
== :: CacheResult -> CacheResult -> Bool
$c/= :: CacheResult -> CacheResult -> Bool
/= :: CacheResult -> CacheResult -> Bool
Eq, (forall x. CacheResult -> Rep CacheResult x)
-> (forall x. Rep CacheResult x -> CacheResult)
-> Generic CacheResult
forall x. Rep CacheResult x -> CacheResult
forall x. CacheResult -> Rep CacheResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CacheResult -> Rep CacheResult x
from :: forall x. CacheResult -> Rep CacheResult x
$cto :: forall x. Rep CacheResult x -> CacheResult
to :: forall x. Rep CacheResult x -> CacheResult
Generic, Int -> CacheResult -> ShowS
[CacheResult] -> ShowS
CacheResult -> String
(Int -> CacheResult -> ShowS)
-> (CacheResult -> String)
-> ([CacheResult] -> ShowS)
-> Show CacheResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CacheResult -> ShowS
showsPrec :: Int -> CacheResult -> ShowS
$cshow :: CacheResult -> String
show :: CacheResult -> String
$cshowList :: [CacheResult] -> ShowS
showList :: [CacheResult] -> ShowS
Show)

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

-- | The independently budgeted metadata stores.
data CacheStore = FullStore | VersionStore | AssembledStore
    deriving stock (CacheStore -> CacheStore -> Bool
(CacheStore -> CacheStore -> Bool)
-> (CacheStore -> CacheStore -> Bool) -> Eq CacheStore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CacheStore -> CacheStore -> Bool
== :: CacheStore -> CacheStore -> Bool
$c/= :: CacheStore -> CacheStore -> Bool
/= :: CacheStore -> CacheStore -> Bool
Eq, (forall x. CacheStore -> Rep CacheStore x)
-> (forall x. Rep CacheStore x -> CacheStore) -> Generic CacheStore
forall x. Rep CacheStore x -> CacheStore
forall x. CacheStore -> Rep CacheStore x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CacheStore -> Rep CacheStore x
from :: forall x. CacheStore -> Rep CacheStore x
$cto :: forall x. Rep CacheStore x -> CacheStore
to :: forall x. Rep CacheStore x -> CacheStore
Generic, Int -> CacheStore -> ShowS
[CacheStore] -> ShowS
CacheStore -> String
(Int -> CacheStore -> ShowS)
-> (CacheStore -> String)
-> ([CacheStore] -> ShowS)
-> Show CacheStore
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CacheStore -> ShowS
showsPrec :: Int -> CacheStore -> ShowS
$cshow :: CacheStore -> String
show :: CacheStore -> String
$cshowList :: [CacheStore] -> ShowS
showList :: [CacheStore] -> ShowS
Show)

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

{- | A processed mirror job's result. The idempotent "already present" outcome (a registry
@409@) counts as 'Published', not as a distinct value.
-}
data MirrorResult
    = -- | The artifact reached the mirror target (an already-present version included).
      Published
    | -- | The job did not publish, and its message stays in the queue's own hands.
      Failed
    | {- | The worker retired the message itself, once it spent the queue's redelivery budget.
      The terminus when no dead-letter queue exists, so an operator alerts on it.
      -}
      Discarded
    deriving stock (MirrorResult -> MirrorResult -> Bool
(MirrorResult -> MirrorResult -> Bool)
-> (MirrorResult -> MirrorResult -> Bool) -> Eq MirrorResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MirrorResult -> MirrorResult -> Bool
== :: MirrorResult -> MirrorResult -> Bool
$c/= :: MirrorResult -> MirrorResult -> Bool
/= :: MirrorResult -> MirrorResult -> Bool
Eq, (forall x. MirrorResult -> Rep MirrorResult x)
-> (forall x. Rep MirrorResult x -> MirrorResult)
-> Generic MirrorResult
forall x. Rep MirrorResult x -> MirrorResult
forall x. MirrorResult -> Rep MirrorResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MirrorResult -> Rep MirrorResult x
from :: forall x. MirrorResult -> Rep MirrorResult x
$cto :: forall x. Rep MirrorResult x -> MirrorResult
to :: forall x. Rep MirrorResult x -> MirrorResult
Generic, Int -> MirrorResult -> ShowS
[MirrorResult] -> ShowS
MirrorResult -> String
(Int -> MirrorResult -> ShowS)
-> (MirrorResult -> String)
-> ([MirrorResult] -> ShowS)
-> Show MirrorResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MirrorResult -> ShowS
showsPrec :: Int -> MirrorResult -> ShowS
$cshow :: MirrorResult -> String
show :: MirrorResult -> String
$cshowList :: [MirrorResult] -> ShowS
showList :: [MirrorResult] -> ShowS
Show)

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

-- | The bounded registry role of a sweep observation or operation.
data SweepTarget
    = -- | The source that receives mirrored packages.
      SweepMirror
    | -- | The associated cache used for private reads.
      SweepPrivate
    deriving stock (SweepTarget -> SweepTarget -> Bool
(SweepTarget -> SweepTarget -> Bool)
-> (SweepTarget -> SweepTarget -> Bool) -> Eq SweepTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SweepTarget -> SweepTarget -> Bool
== :: SweepTarget -> SweepTarget -> Bool
$c/= :: SweepTarget -> SweepTarget -> Bool
/= :: SweepTarget -> SweepTarget -> Bool
Eq, (forall x. SweepTarget -> Rep SweepTarget x)
-> (forall x. Rep SweepTarget x -> SweepTarget)
-> Generic SweepTarget
forall x. Rep SweepTarget x -> SweepTarget
forall x. SweepTarget -> Rep SweepTarget x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SweepTarget -> Rep SweepTarget x
from :: forall x. SweepTarget -> Rep SweepTarget x
$cto :: forall x. Rep SweepTarget x -> SweepTarget
to :: forall x. Rep SweepTarget x -> SweepTarget
Generic, Eq SweepTarget
Eq SweepTarget =>
(SweepTarget -> SweepTarget -> Ordering)
-> (SweepTarget -> SweepTarget -> Bool)
-> (SweepTarget -> SweepTarget -> Bool)
-> (SweepTarget -> SweepTarget -> Bool)
-> (SweepTarget -> SweepTarget -> Bool)
-> (SweepTarget -> SweepTarget -> SweepTarget)
-> (SweepTarget -> SweepTarget -> SweepTarget)
-> Ord SweepTarget
SweepTarget -> SweepTarget -> Bool
SweepTarget -> SweepTarget -> Ordering
SweepTarget -> SweepTarget -> SweepTarget
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 :: SweepTarget -> SweepTarget -> Ordering
compare :: SweepTarget -> SweepTarget -> Ordering
$c< :: SweepTarget -> SweepTarget -> Bool
< :: SweepTarget -> SweepTarget -> Bool
$c<= :: SweepTarget -> SweepTarget -> Bool
<= :: SweepTarget -> SweepTarget -> Bool
$c> :: SweepTarget -> SweepTarget -> Bool
> :: SweepTarget -> SweepTarget -> Bool
$c>= :: SweepTarget -> SweepTarget -> Bool
>= :: SweepTarget -> SweepTarget -> Bool
$cmax :: SweepTarget -> SweepTarget -> SweepTarget
max :: SweepTarget -> SweepTarget -> SweepTarget
$cmin :: SweepTarget -> SweepTarget -> SweepTarget
min :: SweepTarget -> SweepTarget -> SweepTarget
Ord, Int -> SweepTarget -> ShowS
[SweepTarget] -> ShowS
SweepTarget -> String
(Int -> SweepTarget -> ShowS)
-> (SweepTarget -> String)
-> ([SweepTarget] -> ShowS)
-> Show SweepTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SweepTarget -> ShowS
showsPrec :: Int -> SweepTarget -> ShowS
$cshow :: SweepTarget -> String
show :: SweepTarget -> String
$cshowList :: [SweepTarget] -> ShowS
showList :: [SweepTarget] -> ShowS
Show)

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

-- | The disposition of one observed version or logical preview selection.
data SweepResult
    = -- | The sweep evaluated the version.
      SweepExamined
    | -- | A named decisive deny removed it.
      SweepDeleted
    | -- | A named decisive deny would have removed it, under a dry run.
      SweepWouldDelete
    | -- | Nothing decisively denied it, so it stays.
      SweepKept
    | -- | A safety control held it back: the first-party belt, or the cycle's deletion cap.
      SweepGuardSkipped
    deriving stock (SweepResult -> SweepResult -> Bool
(SweepResult -> SweepResult -> Bool)
-> (SweepResult -> SweepResult -> Bool) -> Eq SweepResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SweepResult -> SweepResult -> Bool
== :: SweepResult -> SweepResult -> Bool
$c/= :: SweepResult -> SweepResult -> Bool
/= :: SweepResult -> SweepResult -> Bool
Eq, (forall x. SweepResult -> Rep SweepResult x)
-> (forall x. Rep SweepResult x -> SweepResult)
-> Generic SweepResult
forall x. Rep SweepResult x -> SweepResult
forall x. SweepResult -> Rep SweepResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SweepResult -> Rep SweepResult x
from :: forall x. SweepResult -> Rep SweepResult x
$cto :: forall x. Rep SweepResult x -> SweepResult
to :: forall x. Rep SweepResult x -> SweepResult
Generic, Int -> SweepResult -> ShowS
[SweepResult] -> ShowS
SweepResult -> String
(Int -> SweepResult -> ShowS)
-> (SweepResult -> String)
-> ([SweepResult] -> ShowS)
-> Show SweepResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SweepResult -> ShowS
showsPrec :: Int -> SweepResult -> ShowS
$cshow :: SweepResult -> String
show :: SweepResult -> String
$cshowList :: [SweepResult] -> ShowS
showList :: [SweepResult] -> ShowS
Show)

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

-- | A credential-refresh result.
data CredentialResult = Refreshed | RefreshFailed
    deriving stock (CredentialResult -> CredentialResult -> Bool
(CredentialResult -> CredentialResult -> Bool)
-> (CredentialResult -> CredentialResult -> Bool)
-> Eq CredentialResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CredentialResult -> CredentialResult -> Bool
== :: CredentialResult -> CredentialResult -> Bool
$c/= :: CredentialResult -> CredentialResult -> Bool
/= :: CredentialResult -> CredentialResult -> Bool
Eq, (forall x. CredentialResult -> Rep CredentialResult x)
-> (forall x. Rep CredentialResult x -> CredentialResult)
-> Generic CredentialResult
forall x. Rep CredentialResult x -> CredentialResult
forall x. CredentialResult -> Rep CredentialResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CredentialResult -> Rep CredentialResult x
from :: forall x. CredentialResult -> Rep CredentialResult x
$cto :: forall x. Rep CredentialResult x -> CredentialResult
to :: forall x. Rep CredentialResult x -> CredentialResult
Generic, Int -> CredentialResult -> ShowS
[CredentialResult] -> ShowS
CredentialResult -> String
(Int -> CredentialResult -> ShowS)
-> (CredentialResult -> String)
-> ([CredentialResult] -> ShowS)
-> Show CredentialResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CredentialResult -> ShowS
showsPrec :: Int -> CredentialResult -> ShowS
$cshow :: CredentialResult -> String
show :: CredentialResult -> String
$cshowList :: [CredentialResult] -> ShowS
showList :: [CredentialResult] -> ShowS
Show)

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

{- | What one advisory sync attempt concluded. It labels the @ecluse.advisory.sync.*@ signals
and the sync span alike.
-}
data AdvisorySyncResult
    = -- | The sync verified a new artifact and swapped it into the read path.
      AdvisorySwapped
    | -- | The remote artifact matches the last seen one.
      AdvisoryUnchanged
    | -- | No artifact exists in the bucket yet.
      AdvisoryNonePublished
    | -- | The fetch itself did not deliver the object.
      AdvisoryFetchFailed
    | -- | Verification refused the downloaded artifact.
      AdvisoryRefused
    deriving stock (AdvisorySyncResult -> AdvisorySyncResult -> Bool
(AdvisorySyncResult -> AdvisorySyncResult -> Bool)
-> (AdvisorySyncResult -> AdvisorySyncResult -> Bool)
-> Eq AdvisorySyncResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdvisorySyncResult -> AdvisorySyncResult -> Bool
== :: AdvisorySyncResult -> AdvisorySyncResult -> Bool
$c/= :: AdvisorySyncResult -> AdvisorySyncResult -> Bool
/= :: AdvisorySyncResult -> AdvisorySyncResult -> Bool
Eq, (forall x. AdvisorySyncResult -> Rep AdvisorySyncResult x)
-> (forall x. Rep AdvisorySyncResult x -> AdvisorySyncResult)
-> Generic AdvisorySyncResult
forall x. Rep AdvisorySyncResult x -> AdvisorySyncResult
forall x. AdvisorySyncResult -> Rep AdvisorySyncResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AdvisorySyncResult -> Rep AdvisorySyncResult x
from :: forall x. AdvisorySyncResult -> Rep AdvisorySyncResult x
$cto :: forall x. Rep AdvisorySyncResult x -> AdvisorySyncResult
to :: forall x. Rep AdvisorySyncResult x -> AdvisorySyncResult
Generic, Int -> AdvisorySyncResult -> ShowS
[AdvisorySyncResult] -> ShowS
AdvisorySyncResult -> String
(Int -> AdvisorySyncResult -> ShowS)
-> (AdvisorySyncResult -> String)
-> ([AdvisorySyncResult] -> ShowS)
-> Show AdvisorySyncResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AdvisorySyncResult -> ShowS
showsPrec :: Int -> AdvisorySyncResult -> ShowS
$cshow :: AdvisorySyncResult -> String
show :: AdvisorySyncResult -> String
$cshowList :: [AdvisorySyncResult] -> ShowS
showList :: [AdvisorySyncResult] -> ShowS
Show)

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

{- | The wire value of an advisory sync result. The metric label and the span attribute must
read identically, so the two signals join on it.
-}
advisorySyncResultName :: AdvisorySyncResult -> Text
advisorySyncResultName :: AdvisorySyncResult -> Text
advisorySyncResultName = \case
    AdvisorySyncResult
AdvisorySwapped -> Text
"swapped"
    AdvisorySyncResult
AdvisoryUnchanged -> Text
"unchanged"
    AdvisorySyncResult
AdvisoryNonePublished -> Text
"none_published"
    AdvisorySyncResult
AdvisoryFetchFailed -> Text
"fetch_failed"
    AdvisorySyncResult
AdvisoryRefused -> Text
"refused"

{- | Why a compile pass dropped one advisory entry. The entry's own name and bytes stay on the
drop log line, never a label.
-}
data AdvisoryDropCause
    = -- | The entry breached the per-advisory byte cap.
      DropOversize
    | -- | The entry's JSON did not decode.
      DropMalformed
    deriving stock (AdvisoryDropCause -> AdvisoryDropCause -> Bool
(AdvisoryDropCause -> AdvisoryDropCause -> Bool)
-> (AdvisoryDropCause -> AdvisoryDropCause -> Bool)
-> Eq AdvisoryDropCause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdvisoryDropCause -> AdvisoryDropCause -> Bool
== :: AdvisoryDropCause -> AdvisoryDropCause -> Bool
$c/= :: AdvisoryDropCause -> AdvisoryDropCause -> Bool
/= :: AdvisoryDropCause -> AdvisoryDropCause -> Bool
Eq, (forall x. AdvisoryDropCause -> Rep AdvisoryDropCause x)
-> (forall x. Rep AdvisoryDropCause x -> AdvisoryDropCause)
-> Generic AdvisoryDropCause
forall x. Rep AdvisoryDropCause x -> AdvisoryDropCause
forall x. AdvisoryDropCause -> Rep AdvisoryDropCause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AdvisoryDropCause -> Rep AdvisoryDropCause x
from :: forall x. AdvisoryDropCause -> Rep AdvisoryDropCause x
$cto :: forall x. Rep AdvisoryDropCause x -> AdvisoryDropCause
to :: forall x. Rep AdvisoryDropCause x -> AdvisoryDropCause
Generic, Int -> AdvisoryDropCause -> ShowS
[AdvisoryDropCause] -> ShowS
AdvisoryDropCause -> String
(Int -> AdvisoryDropCause -> ShowS)
-> (AdvisoryDropCause -> String)
-> ([AdvisoryDropCause] -> ShowS)
-> Show AdvisoryDropCause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AdvisoryDropCause -> ShowS
showsPrec :: Int -> AdvisoryDropCause -> ShowS
$cshow :: AdvisoryDropCause -> String
show :: AdvisoryDropCause -> String
$cshowList :: [AdvisoryDropCause] -> ShowS
showList :: [AdvisoryDropCause] -> ShowS
Show)

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

{- | What one compile pass concluded. A pass that never concluded, because a fetch or a
filesystem fault escaped it, records neither value.
-}
data AdvisoryCompileResult
    = -- | The pass finalised an artifact.
      CompileCompleted
    | -- | The pass abandoned the artifact over a systemic drop rate.
      CompileAborted
    deriving stock (AdvisoryCompileResult -> AdvisoryCompileResult -> Bool
(AdvisoryCompileResult -> AdvisoryCompileResult -> Bool)
-> (AdvisoryCompileResult -> AdvisoryCompileResult -> Bool)
-> Eq AdvisoryCompileResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdvisoryCompileResult -> AdvisoryCompileResult -> Bool
== :: AdvisoryCompileResult -> AdvisoryCompileResult -> Bool
$c/= :: AdvisoryCompileResult -> AdvisoryCompileResult -> Bool
/= :: AdvisoryCompileResult -> AdvisoryCompileResult -> Bool
Eq, (forall x. AdvisoryCompileResult -> Rep AdvisoryCompileResult x)
-> (forall x. Rep AdvisoryCompileResult x -> AdvisoryCompileResult)
-> Generic AdvisoryCompileResult
forall x. Rep AdvisoryCompileResult x -> AdvisoryCompileResult
forall x. AdvisoryCompileResult -> Rep AdvisoryCompileResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AdvisoryCompileResult -> Rep AdvisoryCompileResult x
from :: forall x. AdvisoryCompileResult -> Rep AdvisoryCompileResult x
$cto :: forall x. Rep AdvisoryCompileResult x -> AdvisoryCompileResult
to :: forall x. Rep AdvisoryCompileResult x -> AdvisoryCompileResult
Generic, Int -> AdvisoryCompileResult -> ShowS
[AdvisoryCompileResult] -> ShowS
AdvisoryCompileResult -> String
(Int -> AdvisoryCompileResult -> ShowS)
-> (AdvisoryCompileResult -> String)
-> ([AdvisoryCompileResult] -> ShowS)
-> Show AdvisoryCompileResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AdvisoryCompileResult -> ShowS
showsPrec :: Int -> AdvisoryCompileResult -> ShowS
$cshow :: AdvisoryCompileResult -> String
show :: AdvisoryCompileResult -> String
$cshowList :: [AdvisoryCompileResult] -> ShowS
showList :: [AdvisoryCompileResult] -> ShowS
Show)

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

-- | Which circuit breaker a state gauge concerns.
data BreakerSource = EffectfulRule | CredentialMint
    deriving stock (BreakerSource -> BreakerSource -> Bool
(BreakerSource -> BreakerSource -> Bool)
-> (BreakerSource -> BreakerSource -> Bool) -> Eq BreakerSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BreakerSource -> BreakerSource -> Bool
== :: BreakerSource -> BreakerSource -> Bool
$c/= :: BreakerSource -> BreakerSource -> Bool
/= :: BreakerSource -> BreakerSource -> Bool
Eq, (forall x. BreakerSource -> Rep BreakerSource x)
-> (forall x. Rep BreakerSource x -> BreakerSource)
-> Generic BreakerSource
forall x. Rep BreakerSource x -> BreakerSource
forall x. BreakerSource -> Rep BreakerSource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BreakerSource -> Rep BreakerSource x
from :: forall x. BreakerSource -> Rep BreakerSource x
$cto :: forall x. Rep BreakerSource x -> BreakerSource
to :: forall x. Rep BreakerSource x -> BreakerSource
Generic, Int -> BreakerSource -> ShowS
[BreakerSource] -> ShowS
BreakerSource -> String
(Int -> BreakerSource -> ShowS)
-> (BreakerSource -> String)
-> ([BreakerSource] -> ShowS)
-> Show BreakerSource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BreakerSource -> ShowS
showsPrec :: Int -> BreakerSource -> ShowS
$cshow :: BreakerSource -> String
show :: BreakerSource -> String
$cshowList :: [BreakerSource] -> ShowS
showList :: [BreakerSource] -> ShowS
Show)

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

{- | The circuit-breaker state, recorded as the @ecluse.rule.breaker.state@ gauge's value
(labelled by 'BreakerSource'). It is a bounded measurement, not a label.
-}
data BreakerState = Closed | HalfOpen | Open
    deriving stock (BreakerState -> BreakerState -> Bool
(BreakerState -> BreakerState -> Bool)
-> (BreakerState -> BreakerState -> Bool) -> Eq BreakerState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BreakerState -> BreakerState -> Bool
== :: BreakerState -> BreakerState -> Bool
$c/= :: BreakerState -> BreakerState -> Bool
/= :: BreakerState -> BreakerState -> Bool
Eq, (forall x. BreakerState -> Rep BreakerState x)
-> (forall x. Rep BreakerState x -> BreakerState)
-> Generic BreakerState
forall x. Rep BreakerState x -> BreakerState
forall x. BreakerState -> Rep BreakerState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BreakerState -> Rep BreakerState x
from :: forall x. BreakerState -> Rep BreakerState x
$cto :: forall x. Rep BreakerState x -> BreakerState
to :: forall x. Rep BreakerState x -> BreakerState
Generic, Int -> BreakerState -> ShowS
[BreakerState] -> ShowS
BreakerState -> String
(Int -> BreakerState -> ShowS)
-> (BreakerState -> String)
-> ([BreakerState] -> ShowS)
-> Show BreakerState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BreakerState -> ShowS
showsPrec :: Int -> BreakerState -> ShowS
$cshow :: BreakerState -> String
show :: BreakerState -> String
$cshowList :: [BreakerState] -> ShowS
showList :: [BreakerState] -> ShowS
Show)

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

{- | The gauge code for a breaker state. Closed is @0@, so a dashboard alarms on "not
closed" without a high-cardinality label.
-}
breakerStateCode :: BreakerState -> Int64
breakerStateCode :: BreakerState -> Int64
breakerStateCode = \case
    BreakerState
Closed -> Int64
0
    BreakerState
HalfOpen -> Int64
1
    BreakerState
Open -> Int64
2

{- | A single metric label. No constructor takes a package, version, scope, or message. 'LRule'
is the one operator-bounded label, since a deployment defines a small, fixed rule set.
-}
data Label
    = LDecision Decision
    | LReasonClass ReasonClass
    | LRule Text
    | LEcosystem Ecosystem
    | LMount Ecosystem
    | LUpstream Upstream
    | LStatusClass StatusClass
    | LCacheResult CacheResult
    | LCacheStore CacheStore
    | LMirrorResult MirrorResult
    | LSweepResult SweepResult
    | LSweepTarget SweepTarget
    | LCredentialResult CredentialResult
    | LAdvisorySyncResult AdvisorySyncResult
    | LAdvisoryCompileResult AdvisoryCompileResult
    | LAdvisoryDropCause AdvisoryDropCause
    | LProvider Provider
    | LCause Cause
    | LBreakerSource BreakerSource
    | LTier Tier
    | LPerimeterCause RequestFaultCause
    | LRelayAnomaly RelayAnomaly
    deriving stock (Label -> Label -> Bool
(Label -> Label -> Bool) -> (Label -> Label -> Bool) -> Eq Label
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Label -> Label -> Bool
== :: Label -> Label -> Bool
$c/= :: Label -> Label -> Bool
/= :: Label -> Label -> Bool
Eq, Int -> Label -> ShowS
[Label] -> ShowS
Label -> String
(Int -> Label -> ShowS)
-> (Label -> String) -> ([Label] -> ShowS) -> Show Label
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Label -> ShowS
showsPrec :: Int -> Label -> ShowS
$cshow :: Label -> String
show :: Label -> String
$cshowList :: [Label] -> ShowS
showList :: [Label] -> ShowS
Show)

-- | The 'LabelKey' a 'Label' is filed under.
labelKey :: Label -> LabelKey
labelKey :: Label -> LabelKey
labelKey = \case
    LDecision{} -> LabelKey
KeyDecision
    LReasonClass{} -> LabelKey
KeyReasonClass
    LRule{} -> LabelKey
KeyRule
    LEcosystem{} -> LabelKey
KeyEcosystem
    LMount{} -> LabelKey
KeyMount
    LUpstream{} -> LabelKey
KeyUpstream
    LStatusClass{} -> LabelKey
KeyStatusClass
    LCacheResult{} -> LabelKey
KeyResult
    LCacheStore{} -> LabelKey
KeyStore
    LMirrorResult{} -> LabelKey
KeyResult
    LSweepResult{} -> LabelKey
KeyResult
    LSweepTarget{} -> LabelKey
KeyTarget
    LCredentialResult{} -> LabelKey
KeyResult
    LAdvisorySyncResult{} -> LabelKey
KeyResult
    LAdvisoryCompileResult{} -> LabelKey
KeyResult
    LAdvisoryDropCause{} -> LabelKey
KeyCause
    LProvider{} -> LabelKey
KeyProvider
    LCause{} -> LabelKey
KeyCause
    LBreakerSource{} -> LabelKey
KeyBreakerSource
    LTier{} -> LabelKey
KeyTier
    LPerimeterCause{} -> LabelKey
KeyCause
    LRelayAnomaly{} -> LabelKey
KeyCause

-- | Project a 'Label' to its @(key, value)@ wire pair.
renderLabel :: Label -> (Text, Text)
renderLabel :: Label -> (Text, Text)
renderLabel Label
label = (LabelKey -> Text
labelKeyName (Label -> LabelKey
labelKey Label
label), Label -> Text
labelValue Label
label)

labelValue :: Label -> Text
labelValue :: Label -> Text
labelValue = \case
    LDecision Decision
d -> case Decision
d of
        Decision
Admit -> Text
"admit"
        Decision
Deny -> Text
"deny"
        Decision
Unavailable -> Text
"unavailable"
    LReasonClass ReasonClass
r -> case ReasonClass
r of
        ReasonClass
ReasonPolicy -> Text
"policy"
        ReasonClass
ReasonMissingIntegrity -> Text
"missing_integrity"
        ReasonClass
ReasonUnavailable -> Text
"unavailable"
        ReasonClass
ReasonLimit -> Text
"limit"
    LRule Text
name -> Text
name
    LEcosystem Ecosystem
eco -> Ecosystem -> Text
ecosystemName Ecosystem
eco
    LMount Ecosystem
eco -> Ecosystem -> Text
ecosystemName Ecosystem
eco
    LUpstream Upstream
u -> case Upstream
u of
        Upstream
Private -> Text
"private"
        Upstream
Public -> Text
"public"
    LStatusClass StatusClass
s -> case StatusClass
s of
        StatusClass
Status2xx -> Text
"2xx"
        StatusClass
Status3xx -> Text
"3xx"
        StatusClass
Status4xx -> Text
"4xx"
        StatusClass
Status5xx -> Text
"5xx"
        StatusClass
StatusOther -> Text
"other"
    LCacheResult CacheResult
c -> case CacheResult
c of
        CacheResult
Hit -> Text
"hit"
        CacheResult
Miss -> Text
"miss"
        CacheResult
Collapsed -> Text
"collapsed"
    LCacheStore CacheStore
store -> case CacheStore
store of
        CacheStore
FullStore -> Text
"full"
        CacheStore
VersionStore -> Text
"version"
        CacheStore
AssembledStore -> Text
"assembled"
    LMirrorResult MirrorResult
m -> case MirrorResult
m of
        MirrorResult
Published -> Text
"published"
        MirrorResult
Failed -> Text
"failed"
        MirrorResult
Discarded -> Text
"discarded"
    LSweepTarget SweepTarget
target -> case SweepTarget
target of
        SweepTarget
SweepMirror -> Text
"mirrorTarget"
        SweepTarget
SweepPrivate -> Text
"privateUpstream"
    LSweepResult SweepResult
r -> case SweepResult
r of
        SweepResult
SweepExamined -> Text
"examined"
        SweepResult
SweepDeleted -> Text
"deleted"
        SweepResult
SweepWouldDelete -> Text
"would_delete"
        SweepResult
SweepKept -> Text
"kept"
        SweepResult
SweepGuardSkipped -> Text
"guard_skipped"
    LCredentialResult CredentialResult
c -> case CredentialResult
c of
        CredentialResult
Refreshed -> Text
"refreshed"
        CredentialResult
RefreshFailed -> Text
"failed"
    LAdvisorySyncResult AdvisorySyncResult
r -> AdvisorySyncResult -> Text
advisorySyncResultName AdvisorySyncResult
r
    LAdvisoryCompileResult AdvisoryCompileResult
r -> case AdvisoryCompileResult
r of
        AdvisoryCompileResult
CompileCompleted -> Text
"completed"
        AdvisoryCompileResult
CompileAborted -> Text
"aborted"
    LAdvisoryDropCause AdvisoryDropCause
c -> case AdvisoryDropCause
c of
        AdvisoryDropCause
DropOversize -> Text
"oversize"
        AdvisoryDropCause
DropMalformed -> Text
"malformed"
    LProvider Provider
p -> case Provider
p of
        Provider
ProviderRegistry -> Text
"registry"
        Provider
ProviderCodeArtifact -> Text
"codeArtifact"
        Provider
ProviderVerdaccio -> Text
"verdaccio"
    LCause Cause
c -> case Cause
c of
        Cause
Timeout -> Text
"timeout"
        Cause
Connection -> Text
"connection"
        Cause
Decode -> Text
"decode"
        Cause
UpstreamStatus -> Text
"upstream_status"
        Cause
OtherCause -> Text
"other"
    LBreakerSource BreakerSource
b -> case BreakerSource
b of
        BreakerSource
EffectfulRule -> Text
"effectful_rule"
        BreakerSource
CredentialMint -> Text
"credential_mint"
    LTier Tier
t -> case Tier
t of
        Tier
Structural -> Text
"structural"
        Tier
Effectful -> Text
"effectful"
    LPerimeterCause RequestFaultCause
c -> case RequestFaultCause
c of
        RequestFaultCause
RenderFault -> Text
"render"
        RequestFaultCause
UnclassifiedFault -> Text
"unclassified"
    LRelayAnomaly RelayAnomaly
a -> case RelayAnomaly
a of
        RelayAnomaly
RelayOddShape -> Text
"odd_shape"
        RelayAnomaly
RelayNonSuccess -> Text
"non_success"

-- | Materialise bounded labels into the attributes recorded by an OpenTelemetry instrument.
metricAttributes :: [Label] -> Attributes
metricAttributes :: [Label] -> Attributes
metricAttributes [Label]
labels =
    AttributeLimits -> Attributes -> AttrsBuilder -> Attributes
addAttributesFromBuilder
        AttributeLimits
defaultAttributeLimits
        Attributes
emptyAttributes
        ((Label -> AttrsBuilder) -> [Label] -> AttrsBuilder
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\Label
label -> let (Text
key, Text
value) = Label -> (Text, Text)
renderLabel Label
label in Text -> Text -> AttrsBuilder
forall a. ToAttribute a => Text -> a -> AttrsBuilder
attr Text
key Text
value) [Label]
labels)