use root/engine::Engine
use root/engine/log::|debug
use root/engine/log::|error
use root/engine/log::|info
use root/engine/log::|trace
use root/engine/log::|warning
use root/engine/log::logBlock
use root/engine/log::logStream
use root/engine/log::logDataBlock
use root/engine/log::logDataStream
use root/engine/log::logBlockLabel
use root/engine/log::logStreamLabel
use root/engine/log::logDataBlockLabel
use root/engine/log::logDataStreamLabel
use root/flow::emit
/**
Log a fixed debug message when triggered.
Emits `message` to the engine log at debug level with the given `label` whenever `trigger` fires.
*/
treatment logDebugMessage(label: string = "debug", message: string)
model engine: Engine()
input trigger: Block<void>
{
emit<string>(value=message)
logBlock[engine=engine](level = |debug(), label = label)
Self.trigger -> emit.trigger,emit -> logBlock.message
}
/**
Log a single debug-level message block.
Forwards `message` to the engine log at debug level with the given `label`.
*/
treatment logDebug(label: string = "debug")
model engine: Engine()
input message: Block<string>
{
logBlock[engine=engine](level = |debug(), label = label)
Self.message -> logBlock.message
}
/**
Log a stream of debug-level messages.
Each string in `messages` is forwarded to the engine log at debug level with the given `label`.
*/
treatment logDebugs(label: string = "debug")
model engine: Engine()
input messages: Stream<string>
{
logStream[engine=engine](level = |debug(), label = label)
Self.messages -> logStream.messages
}
/**
Log a single displayable value at debug level.
Converts `data` to its display representation and logs it at debug level with the given `label`.
*/
treatment logDataDebug<D: Display>(label: string = "debug")
model engine: Engine()
input data: Block<D>
{
logDataBlock<D>[engine=engine](level = |debug(), label = label)
Self.data -> logDataBlock.display
}
/**
Log a stream of displayable values at debug level.
Each item in `data` is converted to its display representation and logged at debug level with the given `label`.
*/
treatment logDataDebugs<D: Display>(label: string = "debug")
model engine: Engine()
input data: Stream<D>
{
logDataStream<D>[engine=engine](level = |debug(), label = label)
Self.data -> logDataStream.display
}
/**
Log a fixed error message when triggered.
Emits `message` to the engine log at error level with the given `label` whenever `trigger` fires.
*/
treatment logErrorMessage(label: string = "error", message: string)
model engine: Engine()
input trigger: Block<void>
{
emit<string>(value=message)
logBlock[engine=engine](level = |error(), label = label)
Self.trigger -> emit.trigger,emit -> logBlock.message
}
/**
Log a single error-level message block.
Forwards `message` to the engine log at error level with the given `label`.
*/
treatment logError(label: string = "error")
model engine: Engine()
input message: Block<string>
{
logBlock[engine=engine](level = |error(), label = label)
Self.message -> logBlock.message
}
/**
Log a stream of error-level messages.
Each string in `messages` is forwarded to the engine log at error level with the given `label`.
*/
treatment logErrors(label: string = "error")
model engine: Engine()
input messages: Stream<string>
{
logStream[engine=engine](level = |error(), label = label)
Self.messages -> logStream.messages
}
/**
Log a single displayable value at error level.
Converts `data` to its display representation and logs it at error level with the given `label`.
*/
treatment logDataError<D: Display>(label: string = "error")
model engine: Engine()
input data: Block<D>
{
logDataBlock<D>[engine=engine](level = |error(), label = label)
Self.data -> logDataBlock.display
}
/**
Log a stream of displayable values at error level.
Each item in `data` is converted to its display representation and logged at error level with the given `label`.
*/
treatment logDataErrors<D: Display>(label: string = "error")
model engine: Engine()
input data: Stream<D>
{
logDataStream<D>[engine=engine](level = |error(), label = label)
Self.data -> logDataStream.display
}
/**
Log a fixed info message when triggered.
Emits `message` to the engine log at info level with the given `label` whenever `trigger` fires.
*/
treatment logInfoMessage(label: string = "info", message: string)
model engine: Engine()
input trigger: Block<void>
{
emit<string>(value=message)
logBlock[engine=engine](level = |info(), label = label)
Self.trigger -> emit.trigger,emit -> logBlock.message
}
/**
Log a single info-level message block.
Forwards `message` to the engine log at info level with the given `label`.
*/
treatment logInfo(label: string = "info")
model engine: Engine()
input message: Block<string>
{
logBlock[engine=engine](level = |info(), label = label)
Self.message -> logBlock.message
}
/**
Log a stream of info-level messages.
Each string in `messages` is forwarded to the engine log at info level with the given `label`.
*/
treatment logInfos(label: string = "info")
model engine: Engine()
input messages: Stream<string>
{
logStream[engine=engine](level = |info(), label = label)
Self.messages -> logStream.messages
}
/**
Log a single displayable value at info level.
Converts `data` to its display representation and logs it at info level with the given `label`.
*/
treatment logDataInfo<D: Display>(label: string = "info")
model engine: Engine()
input data: Block<D>
{
logDataBlock<D>[engine=engine](level = |info(), label = label)
Self.data -> logDataBlock.display
}
/**
Log a stream of displayable values at info level.
Each item in `data` is converted to its display representation and logged at info level with the given `label`.
*/
treatment logDataInfos<D: Display>(label: string = "info")
model engine: Engine()
input data: Stream<D>
{
logDataStream<D>[engine=engine](level = |info(), label = label)
Self.data -> logDataStream.display
}
/**
Log a fixed trace message when triggered.
Emits `message` to the engine log at trace level with the given `label` whenever `trigger` fires.
*/
treatment logTraceMessage(label: string = "trace", message: string)
model engine: Engine()
input trigger: Block<void>
{
emit<string>(value=message)
logBlock[engine=engine](level = |trace(), label = label)
Self.trigger -> emit.trigger,emit -> logBlock.message
}
/**
Log a single trace-level message block.
Forwards `message` to the engine log at trace level with the given `label`.
*/
treatment logTrace(label: string = "trace")
model engine: Engine()
input message: Block<string>
{
logBlock[engine=engine](level = |trace(), label = label)
Self.message -> logBlock.message
}
/**
Log a stream of trace-level messages.
Each string in `messages` is forwarded to the engine log at trace level with the given `label`.
*/
treatment logTraces(label: string = "trace")
model engine: Engine()
input messages: Stream<string>
{
logStream[engine=engine](level = |trace(), label = label)
Self.messages -> logStream.messages
}
/**
Log a single displayable value at trace level.
Converts `data` to its display representation and logs it at trace level with the given `label`.
*/
treatment logDataTrace<D: Display>(label: string = "trace")
model engine: Engine()
input data: Block<D>
{
logDataBlock<D>[engine=engine](level = |trace(), label = label)
Self.data -> logDataBlock.display
}
/**
Log a stream of displayable values at trace level.
Each item in `data` is converted to its display representation and logged at trace level with the given `label`.
*/
treatment logDataTraces<D: Display>(label: string = "trace")
model engine: Engine()
input data: Stream<D>
{
logDataStream<D>[engine=engine](level = |trace(), label = label)
Self.data -> logDataStream.display
}
/**
Log a fixed warning message when triggered.
Emits `message` to the engine log at warning level with the given `label` whenever `trigger` fires.
*/
treatment logWarningMessage(label: string = "warning", message: string)
model engine: Engine()
input trigger: Block<void>
{
emit<string>(value=message)
logBlock[engine=engine](level = |warning(), label = label)
Self.trigger -> emit.trigger,emit -> logBlock.message
}
/**
Log a single warning-level message block.
Forwards `message` to the engine log at warning level with the given `label`.
*/
treatment logWarning(label: string = "warning")
model engine: Engine()
input message: Block<string>
{
logBlock[engine=engine](level = |warning(), label = label)
Self.message -> logBlock.message
}
/**
Log a stream of warning-level messages.
Each string in `messages` is forwarded to the engine log at warning level with the given `label`.
*/
treatment logWarnings(label: string = "warning")
model engine: Engine()
input messages: Stream<string>
{
logStream[engine=engine](level = |warning(), label = label)
Self.messages -> logStream.messages
}
/**
Log a single displayable value at warning level.
Converts `data` to its display representation and logs it at warning level with the given `label`.
*/
treatment logDataWarning<D: Display>(label: string = "warning")
model engine: Engine()
input data: Block<D>
{
logDataBlock<D>[engine=engine](level = |warning(), label = label)
Self.data -> logDataBlock.display
}
/**
Log a stream of displayable values at warning level.
Each item in `data` is converted to its display representation and logged at warning level with the given `label`.
*/
treatment logDataWarnings<D: Display>(label: string = "warning")
model engine: Engine()
input data: Stream<D>
{
logDataStream<D>[engine=engine](level = |warning(), label = label)
Self.data -> logDataStream.display
}
/**
Log a single debug-level message with a streamed label.
Both `label` and `message` are received as blocks, allowing the label to vary at runtime.
*/
treatment logDebugLabel()
model engine: Engine()
input label: Block<string>
input message: Block<string>
{
logBlockLabel[engine=engine](level = |debug())
Self.label ---> logBlockLabel.label
Self.message -> logBlockLabel.message
}
/**
Log a stream of debug-level messages with a streamed label.
`label` is received as a block; each string in `messages` is logged at debug level under that label.
*/
treatment logDebugsLabel()
model engine: Engine()
input label: Block<string>
input messages: Stream<string>
{
logStreamLabel[engine=engine](level = |debug())
Self.label ----> logStreamLabel.label
Self.messages -> logStreamLabel.messages
}
/**
Log a single displayable value at debug level with a streamed label.
Both `label` and `data` are received as blocks; `data` is converted to its display form before logging.
*/
treatment logDataDebugLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Block<D>
{
logDataBlockLabel<D>[engine=engine](level = |debug())
Self.label -> logDataBlockLabel.label
Self.data --> logDataBlockLabel.display
}
/**
Log a stream of displayable values at debug level with a streamed label.
`label` is received as a block; each item in `data` is converted to its display form and logged at debug level.
*/
treatment logDataDebugsLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Stream<D>
{
logDataStreamLabel<D>[engine=engine](level = |debug())
Self.label -> logDataStreamLabel.label
Self.data --> logDataStreamLabel.display
}
/**
Log a single error-level message with a streamed label.
Both `label` and `message` are received as blocks, allowing the label to vary at runtime.
*/
treatment logErrorLabel()
model engine: Engine()
input label: Block<string>
input message: Block<string>
{
logBlockLabel[engine=engine](level = |error())
Self.label ---> logBlockLabel.label
Self.message -> logBlockLabel.message
}
/**
Log a stream of error-level messages with a streamed label.
`label` is received as a block; each string in `messages` is logged at error level under that label.
*/
treatment logErrorsLabel()
model engine: Engine()
input label: Block<string>
input messages: Stream<string>
{
logStreamLabel[engine=engine](level = |error())
Self.label ----> logStreamLabel.label
Self.messages -> logStreamLabel.messages
}
/**
Log a single displayable value at error level with a streamed label.
Both `label` and `data` are received as blocks; `data` is converted to its display form before logging.
*/
treatment logDataErrorLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Block<D>
{
logDataBlockLabel<D>[engine=engine](level = |error())
Self.label -> logDataBlockLabel.label
Self.data --> logDataBlockLabel.display
}
/**
Log a stream of displayable values at error level with a streamed label.
`label` is received as a block; each item in `data` is converted to its display form and logged at error level.
*/
treatment logDataErrorsLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Stream<D>
{
logDataStreamLabel<D>[engine=engine](level = |error())
Self.label -> logDataStreamLabel.label
Self.data --> logDataStreamLabel.display
}
/**
Log a single trace-level message with a streamed label.
Both `label` and `message` are received as blocks, allowing the label to vary at runtime.
*/
treatment logTraceLabel()
model engine: Engine()
input label: Block<string>
input message: Block<string>
{
logBlockLabel[engine=engine](level = |trace())
Self.label ---> logBlockLabel.label
Self.message -> logBlockLabel.message
}
/**
Log a stream of trace-level messages with a streamed label.
`label` is received as a block; each string in `messages` is logged at trace level under that label.
*/
treatment logTracesLabel()
model engine: Engine()
input label: Block<string>
input messages: Stream<string>
{
logStreamLabel[engine=engine](level = |trace())
Self.label ----> logStreamLabel.label
Self.messages -> logStreamLabel.messages
}
/**
Log a single displayable value at trace level with a streamed label.
Both `label` and `data` are received as blocks; `data` is converted to its display form before logging.
*/
treatment logDataTraceLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Block<D>
{
logDataBlockLabel<D>[engine=engine](level = |trace())
Self.label -> logDataBlockLabel.label
Self.data --> logDataBlockLabel.display
}
/**
Log a stream of displayable values at trace level with a streamed label.
`label` is received as a block; each item in `data` is converted to its display form and logged at trace level.
*/
treatment logDataTracesLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Stream<D>
{
logDataStreamLabel<D>[engine=engine](level = |trace())
Self.label -> logDataStreamLabel.label
Self.data --> logDataStreamLabel.display
}
/**
Log a single info-level message with a streamed label.
Both `label` and `message` are received as blocks, allowing the label to vary at runtime.
*/
treatment logInfoLabel()
model engine: Engine()
input label: Block<string>
input message: Block<string>
{
logBlockLabel[engine=engine](level = |info())
Self.label ---> logBlockLabel.label
Self.message -> logBlockLabel.message
}
/**
Log a stream of info-level messages with a streamed label.
`label` is received as a block; each string in `messages` is logged at info level under that label.
*/
treatment logInfosLabel()
model engine: Engine()
input label: Block<string>
input messages: Stream<string>
{
logStreamLabel[engine=engine](level = |info())
Self.label ----> logStreamLabel.label
Self.messages -> logStreamLabel.messages
}
/**
Log a single displayable value at info level with a streamed label.
Both `label` and `data` are received as blocks; `data` is converted to its display form before logging.
*/
treatment logDataInfoLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Block<D>
{
logDataBlockLabel<D>[engine=engine](level = |info())
Self.label -> logDataBlockLabel.label
Self.data --> logDataBlockLabel.display
}
/**
Log a stream of displayable values at info level with a streamed label.
`label` is received as a block; each item in `data` is converted to its display form and logged at info level.
*/
treatment logDataInfosLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Stream<D>
{
logDataStreamLabel<D>[engine=engine](level = |info())
Self.label -> logDataStreamLabel.label
Self.data --> logDataStreamLabel.display
}
/**
Log a single warning-level message with a streamed label.
Both `label` and `message` are received as blocks, allowing the label to vary at runtime.
*/
treatment logWarningLabel()
model engine: Engine()
input label: Block<string>
input message: Block<string>
{
logBlockLabel[engine=engine](level = |warning())
Self.label ---> logBlockLabel.label
Self.message -> logBlockLabel.message
}
/**
Log a stream of warning-level messages with a streamed label.
`label` is received as a block; each string in `messages` is logged at warning level under that label.
*/
treatment logWarningsLabel()
model engine: Engine()
input label: Block<string>
input messages: Stream<string>
{
logStreamLabel[engine=engine](level = |warning())
Self.label ----> logStreamLabel.label
Self.messages -> logStreamLabel.messages
}
/**
Log a single displayable value at warning level with a streamed label.
Both `label` and `data` are received as blocks; `data` is converted to its display form before logging.
*/
treatment logDataWarningLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Block<D>
{
logDataBlockLabel<D>[engine=engine](level = |warning())
Self.label -> logDataBlockLabel.label
Self.data --> logDataBlockLabel.display
}
/**
Log a stream of displayable values at warning level with a streamed label.
`label` is received as a block; each item in `data` is converted to its display form and logged at warning level.
*/
treatment logDataWarningsLabel<D: Display>()
model engine: Engine()
input label: Block<string>
input data: Stream<D>
{
logDataStreamLabel<D>[engine=engine](level = |warning())
Self.label -> logDataStreamLabel.label
Self.data --> logDataStreamLabel.display
}