module Platform
(
DoAnythingHandler,
doAnythingHandler,
doAnything,
Internal.LogHandler,
logHandler,
requestId,
silentHandler,
Internal.tracingSpan,
Internal.tracingSpanIO,
Internal.rootTracingSpanIO,
Internal.setTracingSpanDetails,
Internal.setTracingSpanDetailsIO,
Internal.setTracingSpanSummary,
Internal.setTracingSpanSummaryIO,
Internal.markTracingSpanFailed,
Internal.markTracingSpanFailedIO,
Internal.TracingSpan,
Internal.emptyTracingSpan,
Internal.name,
Internal.started,
Internal.finished,
Internal.frame,
Internal.details,
Internal.summary,
Internal.succeeded,
Internal.allocated,
Internal.children,
Internal.Succeeded (Succeeded, Failed, FailedWith),
Internal.TracingSpanDetails (toTracingSpanDetails, fromTracingSpanDetails),
Internal.SomeTracingSpanDetails,
Internal.Renderer (Renderer),
Internal.renderTracingSpanDetails,
Internal.MonotonicTime,
Internal.inMicroseconds,
Platform.DevLog.writeSpanToDevLog,
bracketWithError,
finally,
unsafeThrowException,
)
where
import Basics
import qualified Control.Exception.Safe as Exception
import qualified Control.Monad.Catch as Catch
import qualified Data.Text
import qualified GHC.Stack as Stack
import NriPrelude
import qualified Platform.DevLog
import qualified Platform.DoAnything as DoAnything
import qualified Platform.Internal as Internal
import qualified Task
import Prelude (IO, pure)
type DoAnythingHandler = DoAnything.Handler
doAnythingHandler :: IO DoAnything.Handler
doAnythingHandler :: IO Handler
doAnythingHandler = Handler -> IO Handler
forall (f :: * -> *) a. Applicative f => a -> f a
pure Handler
DoAnything.Handler
doAnything :: DoAnything.Handler -> IO (Result e a) -> Task e a
doAnything :: Handler -> IO (Result e a) -> Task e a
doAnything Handler
_ IO (Result e a)
io = (LogHandler -> IO (Result e a)) -> Task e a
forall x a. (LogHandler -> IO (Result x a)) -> Task x a
Internal.Task (\LogHandler
_ -> IO (Result e a)
io)
bracketWithError ::
Task e a ->
(Internal.Succeeded -> a -> Task e c) ->
(a -> Task e b) ->
Task e b
bracketWithError :: Task e a
-> (Succeeded -> a -> Task e c) -> (a -> Task e b) -> Task e b
bracketWithError (Internal.Task LogHandler -> IO (Result e a)
acquire) Succeeded -> a -> Task e c
release a -> Task e b
use =
(LogHandler -> IO (Result e b)) -> Task e b
forall x a. (LogHandler -> IO (Result x a)) -> Task x a
Internal.Task ((LogHandler -> IO (Result e b)) -> Task e b)
-> (LogHandler -> IO (Result e b)) -> Task e b
forall a b. (a -> b) -> a -> b
<| \LogHandler
log -> do
(Result e b
eb, Result e c
ec) <-
IO (Result e a)
-> (Result e a -> ExitCase (Result e b) -> IO (Result e c))
-> (Result e a -> IO (Result e b))
-> IO (Result e b, Result e c)
forall (m :: * -> *) a b c.
MonadMask m =>
m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
Exception.generalBracket
(LogHandler -> IO (Result e a)
acquire LogHandler
log)
( \Result e a
eresource ExitCase (Result e b)
exitCase ->
case Result e a
eresource of
Err e
err -> Result e c -> IO (Result e c)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> Result e c
forall error value. error -> Result error value
Err e
err)
Ok a
resource ->
case ExitCase (Result e b)
exitCase of
Catch.ExitCaseSuccess (Ok b
_) -> Task e c -> LogHandler -> IO (Result e c)
forall x a. Task x a -> LogHandler -> IO (Result x a)
Internal._run (Succeeded -> a -> Task e c
release Succeeded
Internal.Succeeded a
resource) LogHandler
log
ExitCase (Result e b)
_ -> Task e c -> LogHandler -> IO (Result e c)
forall x a. Task x a -> LogHandler -> IO (Result x a)
Internal._run (Succeeded -> a -> Task e c
release Succeeded
Internal.Failed a
resource) LogHandler
log
)
( \Result e a
result ->
case Result e a
result of
Err e
err -> Result e b -> IO (Result e b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> Result e b
forall error value. error -> Result error value
Err e
err)
Ok a
x -> Task e b -> LogHandler -> IO (Result e b)
forall x a. Task x a -> LogHandler -> IO (Result x a)
Internal._run (a -> Task e b
use a
x) LogHandler
log
)
Result e b -> IO (Result e b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Result e b -> IO (Result e b)) -> Result e b -> IO (Result e b)
forall a b. (a -> b) -> a -> b
<| do
c
_ <- Result e c
ec
Result e b
eb
finally :: Task e a -> Task e b -> Task e a
finally :: Task e a -> Task e b -> Task e a
finally Task e a
run Task e b
cleanup =
Task e ()
-> (Succeeded -> () -> Task e b) -> (() -> Task e a) -> Task e a
forall e a c b.
Task e a
-> (Succeeded -> a -> Task e c) -> (a -> Task e b) -> Task e b
bracketWithError
(() -> Task e ()
forall a x. a -> Task x a
Task.succeed ())
(\Succeeded
_ ()
_ -> Task e b
cleanup)
(\()
_ -> Task e a
run)
logHandler :: Task e Internal.LogHandler
logHandler :: Task e LogHandler
logHandler = (LogHandler -> IO (Result e LogHandler)) -> Task e LogHandler
forall x a. (LogHandler -> IO (Result x a)) -> Task x a
Internal.Task (Result e LogHandler -> IO (Result e LogHandler)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Result e LogHandler -> IO (Result e LogHandler))
-> (LogHandler -> Result e LogHandler)
-> LogHandler
-> IO (Result e LogHandler)
forall b c a. (b -> c) -> (a -> b) -> a -> c
<< LogHandler -> Result e LogHandler
forall error value. value -> Result error value
Ok)
requestId :: Task e Text
requestId :: Task e Text
requestId = (LogHandler -> Text) -> Task e LogHandler -> Task e Text
forall (m :: * -> *) a value.
Functor m =>
(a -> value) -> m a -> m value
map LogHandler -> Text
Internal.requestId Task e LogHandler
forall e. Task e LogHandler
logHandler
silentHandler :: IO Internal.LogHandler
silentHandler :: IO LogHandler
silentHandler = HasCallStack =>
Text -> Clock -> (TracingSpan -> IO ()) -> Text -> IO LogHandler
Text -> Clock -> (TracingSpan -> IO ()) -> Text -> IO LogHandler
Internal.mkHandler Text
"" (IO MonotonicTime -> Clock
Internal.Clock (MonotonicTime -> IO MonotonicTime
forall (f :: * -> *) a. Applicative f => a -> f a
pure MonotonicTime
0)) (\TracingSpan
_ -> () -> IO ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()) Text
""
unsafeThrowException ::
Stack.HasCallStack =>
Text ->
Task e a
unsafeThrowException :: Text -> Task e a
unsafeThrowException Text
title =
(LogHandler -> IO (Result e a)) -> Task e a
forall x a. (LogHandler -> IO (Result x a)) -> Task x a
Internal.Task
((LogHandler -> IO (Result e a)) -> Task e a)
-> (LogHandler -> IO (Result e a)) -> Task e a
forall a b. (a -> b) -> a -> b
<| \LogHandler
_ ->
String -> IO (Result e a)
forall (m :: * -> *) a.
(MonadThrow m, HasCallStack) =>
String -> m a
Exception.throwString (Text -> String
Data.Text.unpack Text
title)