module Ecluse.Runtime.Env (
Env (..),
newEnvWithAdmission,
withEnvWithAdmission,
serveRuntimeOf,
workerRuntimeOf,
WorkerHeartbeat,
newWorkerHeartbeat,
recordPoll,
lastPoll,
) where
import Katip (LogEnv, Severity (InfoS, WarningS), katipAddContext, sl)
import Network.HTTP.Client (Manager)
import Ecluse.Core.Deadline (Deadlines)
import Ecluse.Core.Queue (MirrorQueue)
import Ecluse.Core.Registry.Backoff (CooldownEvent (..))
import Ecluse.Core.Registry.Exchange.Types (ExchangeClient (ExchangeClient))
import Ecluse.Core.Registry.Public (PublicControl, newPublicControl)
import Ecluse.Core.Security.Authority (HostPort (..))
import Ecluse.Core.Server.Admission (ServeAdmission)
import Ecluse.Core.Server.Admission.Meter (MemoryMeter)
import Ecluse.Core.Server.Cache (MetadataCache)
import Ecluse.Core.Server.Context (ServeRuntime (..))
import Ecluse.Core.Telemetry.Record (MetricsPort (mpUpstreamRequest))
import Ecluse.Core.Worker (WorkerHeartbeat, WorkerPolicies, WorkerRuntime (..), lastPoll, newWorkerHeartbeat, recordPoll)
import Ecluse.Runtime.Log (DdContext, logLine)
import Ecluse.Runtime.Telemetry (Telemetry)
import Ecluse.Runtime.Telemetry.Correlation (ddIdentityFromEnvironment, ddPayloadNow)
import Ecluse.Runtime.Telemetry.Instruments (Metrics, metricsPortOf, newMetrics, workerMetricsPortOf)
import Ecluse.Runtime.Telemetry.Tracing (dataPlaneTrace, tracingPortOf, workerTracingPortOf)
data Env = Env
{ Env -> ServeAdmission
envServeAdmission :: ServeAdmission
, Env -> MemoryMeter
envMemoryMeter :: MemoryMeter
, Env -> MirrorQueue
envQueue :: MirrorQueue
, Env -> ExchangeClient
envPublicClient :: ExchangeClient
, Env -> PublicControl
envPublicControl :: PublicControl
, Env -> ExchangeClient
envPrivateClient :: ExchangeClient
, Env -> Deadlines
envDeadlines :: Deadlines
, Env -> MetadataCache
envMetadataCache :: MetadataCache
, Env -> LogEnv
envLogEnv :: LogEnv
, Env -> Telemetry
envTelemetry :: Telemetry
, Env -> Metrics
envMetrics :: Metrics
, Env -> DdContext
envDdContext :: DdContext
, Env -> WorkerHeartbeat
envWorkerHeartbeat :: WorkerHeartbeat
}
newEnvWithAdmission :: ServeAdmission -> MemoryMeter -> MirrorQueue -> Manager -> Manager -> Deadlines -> MetadataCache -> LogEnv -> Telemetry -> WorkerHeartbeat -> IO Env
newEnvWithAdmission :: ServeAdmission
-> MemoryMeter
-> MirrorQueue
-> Manager
-> Manager
-> Deadlines
-> MetadataCache
-> LogEnv
-> Telemetry
-> WorkerHeartbeat
-> IO Env
newEnvWithAdmission ServeAdmission
admission MemoryMeter
meter MirrorQueue
queue Manager
manager Manager
privateManager Deadlines
deadlines MetadataCache
metadataCache LogEnv
logEnv Telemetry
telemetry WorkerHeartbeat
heartbeat = do
metrics <- Telemetry -> IO Metrics
newMetrics Telemetry
telemetry
tracing <- dataPlaneTrace telemetry
publicControl <- newPublicControl (mpUpstreamRequest (metricsPortOf metrics)) (reportCooldown logEnv)
ddContext <- ddIdentityFromEnvironment
pure
Env
{ envServeAdmission = admission
, envMemoryMeter = meter
, envQueue = queue
, envPublicClient = ExchangeClient manager deadlines tracing
, envPublicControl = publicControl
, envPrivateClient = ExchangeClient privateManager deadlines tracing
, envDeadlines = deadlines
, envMetadataCache = metadataCache
, envLogEnv = logEnv
, envTelemetry = telemetry
, envMetrics = metrics
, envDdContext = ddContext
, envWorkerHeartbeat = heartbeat
}
withEnvWithAdmission ::
(MonadIO m) =>
ServeAdmission ->
MemoryMeter ->
MirrorQueue ->
Manager ->
Manager ->
Deadlines ->
MetadataCache ->
LogEnv ->
Telemetry ->
WorkerHeartbeat ->
(Env -> m a) ->
m a
withEnvWithAdmission :: forall (m :: * -> *) a.
MonadIO m =>
ServeAdmission
-> MemoryMeter
-> MirrorQueue
-> Manager
-> Manager
-> Deadlines
-> MetadataCache
-> LogEnv
-> Telemetry
-> WorkerHeartbeat
-> (Env -> m a)
-> m a
withEnvWithAdmission ServeAdmission
admission MemoryMeter
meter MirrorQueue
queue Manager
manager Manager
privateManager Deadlines
deadlines MetadataCache
metadataCache LogEnv
logEnv Telemetry
telemetry WorkerHeartbeat
heartbeat Env -> m a
action = do
env <- IO Env -> m Env
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ServeAdmission
-> MemoryMeter
-> MirrorQueue
-> Manager
-> Manager
-> Deadlines
-> MetadataCache
-> LogEnv
-> Telemetry
-> WorkerHeartbeat
-> IO Env
newEnvWithAdmission ServeAdmission
admission MemoryMeter
meter MirrorQueue
queue Manager
manager Manager
privateManager Deadlines
deadlines MetadataCache
metadataCache LogEnv
logEnv Telemetry
telemetry WorkerHeartbeat
heartbeat)
action env
serveRuntimeOf :: Env -> ServeRuntime
serveRuntimeOf :: Env -> ServeRuntime
serveRuntimeOf Env
env =
ServeRuntime
{ srAdmission :: ServeAdmission
srAdmission = Env -> ServeAdmission
envServeAdmission Env
env
, srMemoryMeter :: MemoryMeter
srMemoryMeter = Env -> MemoryMeter
envMemoryMeter Env
env
, srPublicClient :: ExchangeClient
srPublicClient = Env -> ExchangeClient
envPublicClient Env
env
, srPublicControl :: PublicControl
srPublicControl = Env -> PublicControl
envPublicControl Env
env
, srPrivateClient :: ExchangeClient
srPrivateClient = Env -> ExchangeClient
envPrivateClient Env
env
, srMetadataCache :: MetadataCache
srMetadataCache = Env -> MetadataCache
envMetadataCache Env
env
, srQueue :: MirrorQueue
srQueue = Env -> MirrorQueue
envQueue Env
env
, srMetrics :: MetricsPort
srMetrics = Metrics -> MetricsPort
metricsPortOf (Env -> Metrics
envMetrics Env
env)
, srTracing :: TracingPort
srTracing = Telemetry -> TracingPort
tracingPortOf (Env -> Telemetry
envTelemetry Env
env)
}
workerRuntimeOf :: WorkerPolicies -> Env -> WorkerRuntime
workerRuntimeOf :: WorkerPolicies -> Env -> WorkerRuntime
workerRuntimeOf WorkerPolicies
policies Env
env =
WorkerRuntime
{ wrQueue :: MirrorQueue
wrQueue = Env -> MirrorQueue
envQueue Env
env
, wrClient :: ExchangeClient
wrClient = Env -> ExchangeClient
envPublicClient Env
env
, wrPublicControl :: PublicControl
wrPublicControl = Env -> PublicControl
envPublicControl Env
env
, wrHeartbeat :: WorkerHeartbeat
wrHeartbeat = Env -> WorkerHeartbeat
envWorkerHeartbeat Env
env
, wrMetrics :: WorkerMetricsPort
wrMetrics = Metrics -> WorkerMetricsPort
workerMetricsPortOf (Env -> Metrics
envMetrics Env
env)
, wrTracing :: WorkerTracingPort
wrTracing = Telemetry -> WorkerTracingPort
workerTracingPortOf (Env -> Telemetry
envTelemetry Env
env)
, wrInjectTraceContext :: forall (m :: * -> *) a. (KatipContext m, MonadIO m) => m a -> m a
wrInjectTraceContext = \m a
action -> do
dd <- IO SimpleLogPayload -> m SimpleLogPayload
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SimpleLogPayload -> m SimpleLogPayload)
-> IO SimpleLogPayload -> m SimpleLogPayload
forall a b. (a -> b) -> a -> b
$ DdContext -> IO SimpleLogPayload
forall (m :: * -> *). MonadIO m => DdContext -> m SimpleLogPayload
ddPayloadNow (Env -> DdContext
envDdContext Env
env)
katipAddContext dd action
, wrPolicies :: WorkerPolicies
wrPolicies = WorkerPolicies
policies
}
reportCooldown :: LogEnv -> HostPort -> CooldownEvent -> IO ()
reportCooldown :: LogEnv -> HostPort -> CooldownEvent -> IO ()
reportCooldown LogEnv
logEnv HostPort
authority CooldownEvent
event = LogEnv -> SimpleLogPayload -> Severity -> Text -> IO ()
logLine LogEnv
logEnv SimpleLogPayload
payload Severity
severity Text
message
where
payload :: SimpleLogPayload
payload = Text -> Text -> SimpleLogPayload
forall a. ToJSON a => Text -> a -> SimpleLogPayload
sl Text
"module" (Text
"Ecluse.Runtime.Env" :: Text) SimpleLogPayload -> SimpleLogPayload -> SimpleLogPayload
forall a. Semigroup a => a -> a -> a
<> Text -> Text -> SimpleLogPayload
forall a. ToJSON a => Text -> a -> SimpleLogPayload
sl Text
"upstream_host" (HostPort -> Text
hpHost HostPort
authority) SimpleLogPayload -> SimpleLogPayload -> SimpleLogPayload
forall a. Semigroup a => a -> a -> a
<> Text -> Word16 -> SimpleLogPayload
forall a. ToJSON a => Text -> a -> SimpleLogPayload
sl Text
"upstream_port" (HostPort -> Word16
hpPort HostPort
authority)
(Severity
severity, Text
message) = case CooldownEvent
event of
CooldownEvent
CoolingDown -> (Severity
WarningS, Text
"public upstream entered cooldown")
CooldownEvent
Recovered -> (Severity
InfoS, Text
"public upstream left cooldown")