tracdap-runtime 0.8.0b1__py3-none-any.whl → 0.8.0b3__py3-none-any.whl

tracdap/rt/{_exec → _impl/exec}/engine.py

@@ -16,18 +16,22 @@
 import copy as cp
 import dataclasses as dc
 import enum
+import io
+import pathlib
 import typing as tp
 
 import tracdap.rt.metadata as _meta
 import tracdap.rt.config as _cfg
 import tracdap.rt.exceptions as _ex
-import tracdap.rt._exec.actors as _actors
-import tracdap.rt._exec.graph_builder as _graph
-import tracdap.rt._exec.functions as _func
-import tracdap.rt._impl.models as _models  # noqa
-import tracdap.rt._impl.data as _data  # noqa
-import tracdap.rt._impl.storage as _storage  # noqa
-import tracdap.rt._impl.util as _util  # noqa
+import tracdap.rt._impl.exec.actors as _actors
+import tracdap.rt._impl.exec.graph_builder as _graph
+import tracdap.rt._impl.exec.functions as _func
+import tracdap.rt._impl.core.config_parser as _cfg_p
+import tracdap.rt._impl.core.data as _data
+import tracdap.rt._impl.core.logging as _logging
+import tracdap.rt._impl.core.models as _models
+import tracdap.rt._impl.core.storage as _storage
+import tracdap.rt._impl.core.util as _util
 
 from .graph import NodeId
 
@@ -79,18 +83,44 @@ class _EngineContext:
             pending_nodes, active_nodes, succeeded_nodes, failed_nodes)
 
 
+@dc.dataclass
+class _JobResultSpec:
+
+    save_result: bool = False
+    result_dir: tp.Union[str, pathlib.Path] = None
+    result_format: str = None
+
+
 @dc.dataclass
 class _JobState:
 
     job_id: _meta.TagHeader
-    actor_id: _actors.ActorId = None
+    log_init: dc.InitVar[tp.Optional[_logging.LogProvider]] = None
 
+    actor_id: _actors.ActorId = None
     monitors: tp.List[_actors.ActorId] = dc.field(default_factory=list)
 
     job_config: _cfg.JobConfig = None
     job_result: _cfg.JobResult = None
     job_error: Exception = None
 
+    parent_key: str = None
+    result_spec: _JobResultSpec = None
+
+    log_buffer: io.BytesIO = None
+    log_provider: _logging.LogProvider = None
+    log: _logging.Logger = None
+
+    def __post_init__(self, log_init):
+
+        if isinstance(self.log, _logging.LogProvider):
+            self.log_provider = log_init
+        else:
+            self.log_buffer = io.BytesIO()
+            self.log_provider = _logging.job_log_provider(self.log_buffer)
+
+        self.log = self.log_provider.logger_for_class(TracEngine)
+
 
 class TracEngine(_actors.Actor):
 
@@ -107,7 +137,7 @@ class TracEngine(_actors.Actor):
 
         super().__init__()
 
-        self._log = _util.logger_for_object(self)
+        self._log = _logging.logger_for_object(self)
 
         self._sys_config = sys_config
         self._models = models
@@ -164,13 +194,17 @@ class TracEngine(_actors.Actor):
             job_result_format: str):
 
         job_key = _util.object_key(job_config.jobId)
+        job_state = _JobState(job_config.jobId)
+
+        job_state.log.info(f"Job submitted: [{job_key}]")
 
         result_needed = bool(job_result_dir)
-        result_spec = _graph.JobResultSpec(result_needed, job_result_dir, job_result_format)
+        result_spec = _JobResultSpec(result_needed, job_result_dir, job_result_format)
 
-        self._log.info(f"Job submitted: [{job_key}]")
+        job_processor = JobProcessor(
+            self._sys_config, self._models, self._storage, job_state.log_provider,
+            job_key, job_config, graph_spec=None)
 
-        job_processor = JobProcessor(self._sys_config, self._models, self._storage, job_key, job_config, result_spec, graph_spec=None)
         job_actor_id = self.actors().spawn(job_processor)
 
         job_monitor_success = lambda ctx, key, result: self._notify_callback(key, result, None)
@@ -178,24 +212,36 @@ class TracEngine(_actors.Actor):
         job_monitor = JobMonitor(job_key, job_monitor_success, job_monitor_failure)
         job_monitor_id = self.actors().spawn(job_monitor)
 
-        job_state = _JobState(job_config.jobId)
         job_state.actor_id = job_actor_id
         job_state.monitors.append(job_monitor_id)
         job_state.job_config = job_config
+        job_state.result_spec = result_spec
 
         self._jobs[job_key] = job_state
 
     @_actors.Message
-    def submit_child_job(self, child_id: _meta.TagHeader, child_graph: _graph.Graph, monitor_id: _actors.ActorId):
+    def submit_child_job(self, parent_key: str, child_id: _meta.TagHeader, child_graph: _graph.Graph, monitor_id: _actors.ActorId):
+
+        parent_state = self._jobs.get(parent_key)
+
+        # Ignore duplicate messages from the job processor (can happen in unusual error cases)
+        if parent_state is None:
+            self._log.warning(f"Ignoring [submit_child_job] message, parent [{parent_key}] has already completed")
+            return
 
         child_key = _util.object_key(child_id)
 
-        child_processor = JobProcessor(self._sys_config, self._models, self._storage, child_key, None, None, graph_spec=child_graph)  # noqa
+        child_processor = JobProcessor(
+            self._sys_config, self._models, self._storage, parent_state.log_provider,
+            child_key, None, graph_spec=child_graph)
+
         child_actor_id = self.actors().spawn(child_processor)
 
-        child_state = _JobState(child_id)
+        child_state = _JobState(child_id, parent_state.log_provider)
         child_state.actor_id = child_actor_id
         child_state.monitors.append(monitor_id)
+        child_state.parent_key = parent_key
+        child_state.result_spec = _JobResultSpec(False)  # Do not output separate results for child jobs
 
         self._jobs[child_key] = child_state
 
@@ -219,9 +265,9 @@ class TracEngine(_actors.Actor):
             self._log.warning(f"Ignoring [job_succeeded] message, job [{job_key}] has already completed")
             return
 
-        self._log.info(f"Recording job as successful: {job_key}")
-
         job_state = self._jobs[job_key]
+        job_state.log.info(f"Recording job as successful: {job_key}")
+
         job_state.job_result = job_result
 
         for monitor_id in job_state.monitors:
@@ -237,11 +283,30 @@ class TracEngine(_actors.Actor):
             self._log.warning(f"Ignoring [job_failed] message, job [{job_key}] has already completed")
             return
 
-        self._log.error(f"Recording job as failed: {job_key}")
-
         job_state = self._jobs[job_key]
+        job_state.log.error(f"Recording job as failed: {job_key}")
+
         job_state.job_error = error
 
+        # Create a failed result so there is something to report
+        result_id = job_state.job_config.resultMapping.get("trac_job_result")
+
+        if result_id is not None:
+
+            job_state.job_result = _cfg.JobResult(
+                jobId=job_state.job_id,
+                statusCode=_meta.JobStatusCode.FAILED,
+                statusMessage=str(error))
+
+            result_def = _meta.ResultDefinition()
+            result_def.jobId = _util.selector_for(job_state.job_id)
+            result_def.statusCode = _meta.JobStatusCode.FAILED
+
+            result_key = _util.object_key(result_id)
+            result_obj = _meta.ObjectDefinition(objectType=_meta.ObjectType.RESULT, result=result_def)
+
+            job_state.job_result.results[result_key] = result_obj
+
         for monitor_id in job_state.monitors:
             self.actors().send(monitor_id, "job_failed", error)
 
@@ -256,6 +321,14 @@ class TracEngine(_actors.Actor):
 
         job_state = self._jobs.get(job_key)
 
+        # Record output metadata if required (not needed for local runs or when using API server)
+        if job_state.parent_key is None and job_state.result_spec.save_result:
+
+            if "trac_job_log_file" in job_state.job_config.resultMapping:
+                self._save_job_log_file(job_key, job_state)
+
+            self._save_job_result(job_key, job_state)
+
         # Stop any monitors that were created directly by the engine
         # (Other actors are responsible for stopping their own monitors)
         while job_state.monitors:
@@ -265,9 +338,57 @@ class TracEngine(_actors.Actor):
                 self.actors().stop(monitor_id)
 
         if job_state.actor_id is not None:
-            self.actors().stop(job_state.actor_id )
+            self.actors().stop(job_state.actor_id)
             job_state.actor_id = None
 
+    def _save_job_log_file(self, job_key: str, job_state: _JobState):
+
+        self._log.info(f"Saving job log file for [{job_key}]")
+
+        # Saving log files could go into a separate actor, perhaps a job monitor along with _save_job_result()
+
+        file_id = job_state.job_config.resultMapping["trac_job_log_file"]
+        storage_id = job_state.job_config.resultMapping["trac_job_log_file:STORAGE"]
+
+        file_type = _meta.FileType("TXT", "text/plain")
+        file_def, storage_def = _graph.GraphBuilder.build_output_file_and_storage(
+            "trac_job_log_file", file_type,
+            self._sys_config, job_state.job_config)
+
+        storage_item = storage_def.dataItems[file_def.dataItem].incarnations[0].copies[0]
+        storage = self._storage.get_file_storage(storage_item.storageKey)
+
+        with storage.write_byte_stream(storage_item.storagePath) as stream:
+            stream.write(job_state.log_buffer.getbuffer())
+            file_def.size = stream.tell()
+
+        result_id = job_state.job_config.resultMapping["trac_job_result"]
+        result_def = job_state.job_result.results[_util.object_key(result_id)].result
+        result_def.logFileId = _util.selector_for(file_id)
+
+        file_obj = _meta.ObjectDefinition(objectType=_meta.ObjectType.FILE, file=file_def)
+        storage_obj = _meta.ObjectDefinition(objectType=_meta.ObjectType.STORAGE, storage=storage_def)
+
+        job_state.job_result.results[_util.object_key(file_id)] = file_obj
+        job_state.job_result.results[_util.object_key(storage_id)] = storage_obj
+
+    def _save_job_result(self, job_key: str, job_state: _JobState):
+
+        self._log.info(f"Saving job result for [{job_key}]")
+
+        # It might be better abstract reporting of results, job status etc., perhaps with a job monitor
+
+        if job_state.result_spec.save_result:
+
+            result_format = job_state.result_spec.result_format
+            result_dir = job_state.result_spec.result_dir
+            result_file = f"job_result_{job_key}.{result_format}"
+            result_path = pathlib.Path(result_dir).joinpath(result_file)
+
+            with open(result_path, "xt") as result_stream:
+                result_content = _cfg_p.ConfigQuoter.quote(job_state.job_result, result_format)
+                result_stream.write(result_content)
+
     def _get_job_info(self, job_key: str, details: bool = False) -> tp.Optional[_cfg.JobResult]:
 
         job_state = self._jobs.get(job_key)
@@ -337,20 +458,24 @@ class JobProcessor(_actors.Actor):
 
     def __init__(
             self, sys_config: _cfg.RuntimeConfig,
-            models: _models.ModelLoader, storage: _storage.StorageManager,
-            job_key: str, job_config: _cfg.JobConfig, result_spec: _graph.JobResultSpec,
-            graph_spec: tp.Optional[_graph.Graph]):
+            models: _models.ModelLoader, storage: _storage.StorageManager, log_provider: _logging.LogProvider,
+            job_key: str, job_config: tp.Optional[_cfg.JobConfig], graph_spec: tp.Optional[_graph.Graph]):
 
         super().__init__()
+
+        # Either a job config or a pre-built spec is required
+        if not job_config and not graph_spec:
+            raise _ex.EUnexpected()
+
         self.job_key = job_key
         self.job_config = job_config
-        self.result_spec = result_spec
         self.graph_spec = graph_spec
         self._sys_config = sys_config
         self._models = models
         self._storage = storage
-        self._resolver = _func.FunctionResolver(models, storage)
-        self._log = _util.logger_for_object(self)
+        self._log_provider = log_provider
+        self._resolver = _func.FunctionResolver(models, storage, log_provider)
+        self._log = log_provider.logger_for_object(self)
 
     def on_start(self):
 
@@ -360,7 +485,7 @@ class JobProcessor(_actors.Actor):
         if self.graph_spec is not None:
             self.actors().send(self.actors().id, "build_graph_succeeded", self.graph_spec)
         else:
-            self.actors().spawn(GraphBuilder(self._sys_config, self.job_config, self.result_spec))
+            self.actors().spawn(GraphBuilder(self._sys_config, self.job_config, self._log_provider))
 
     def on_stop(self):
 
@@ -398,14 +523,14 @@ class JobProcessor(_actors.Actor):
         # Add all the nodes as pending nodes to start
         graph.pending_nodes.update(graph.nodes.keys())
 
-        self.actors().spawn(FunctionResolver(self._resolver, graph))
+        self.actors().spawn(FunctionResolver(self._resolver, self._log_provider, graph))
         if self.actors().sender != self.actors().id and self.actors().sender != self.actors().parent:
             self.actors().stop(self.actors().sender)
 
     @_actors.Message
     def resolve_functions_succeeded(self, graph: _EngineContext):
 
-        self.actors().spawn(GraphProcessor(graph, self._resolver))
+        self.actors().spawn(GraphProcessor(graph, self._resolver, self._log_provider))
         if self.actors().sender != self.actors().id and self.actors().sender != self.actors().parent:
             self.actors().stop(self.actors().sender)
 
@@ -428,12 +553,12 @@ class GraphBuilder(_actors.Actor):
     GraphBuilder is a worker (actor) to wrap the GraphBuilder logic from graph_builder.py
     """
 
-    def __init__(self, sys_config: _cfg.RuntimeConfig, job_config: _cfg.JobConfig, result_spec: _graph.JobResultSpec):
+    def __init__(self, sys_config: _cfg.RuntimeConfig, job_config: _cfg.JobConfig, log_provider: _logging.LogProvider):
+
         super().__init__()
         self.sys_config = sys_config
         self.job_config = job_config
-        self.result_spec = result_spec
-        self._log = _util.logger_for_object(self)
+        self._log = log_provider.logger_for_object(self)
 
     def on_start(self):
         self.build_graph(self, self.job_config)
@@ -443,7 +568,7 @@ class GraphBuilder(_actors.Actor):
 
         self._log.info("Building execution graph")
 
-        graph_builder = _graph.GraphBuilder(self.sys_config, job_config, self.result_spec)
+        graph_builder = _graph.GraphBuilder(self.sys_config, job_config)
         graph_spec = graph_builder.build_job(job_config.job)
 
         self.actors().reply("build_graph_succeeded", graph_spec)
@@ -452,14 +577,14 @@ class GraphBuilder(_actors.Actor):
 class FunctionResolver(_actors.Actor):
 
     """
-    GraphResolver is a worker (actors) to wrap the FunctionResolver logic in functions.py
+    FunctionResolver is a worker (actors) to wrap the FunctionResolver logic in functions.py
     """
 
-    def __init__(self, resolver: _func.FunctionResolver, graph: _EngineContext):
+    def __init__(self, resolver: _func.FunctionResolver, log_provider: _logging.LogProvider, graph: _EngineContext):
         super().__init__()
         self.graph = graph
         self._resolver = resolver
-        self._log = _util.logger_for_object(self)
+        self._log = log_provider.logger_for_object(self)
 
     def on_start(self):
         self.resolve_functions(self, self.graph)
@@ -488,13 +613,15 @@ class GraphProcessor(_actors.Actor):
     Once all running nodes are stopped, an error is reported to the parent
     """
 
-    def __init__(self, graph: _EngineContext, resolver: _func.FunctionResolver):
+    def __init__(self, graph: _EngineContext, resolver: _func.FunctionResolver, log_provider: _logging.LogProvider):
         super().__init__()
         self.graph = graph
         self.root_id_ = graph.root_id
         self.processors: tp.Dict[NodeId, _actors.ActorId] = dict()
         self._resolver = resolver
-        self._log = _util.logger_for_object(self)
+        self._log = log_provider.logger_for_object(self)
+        self._graph_logger = GraphLogger(log_provider)
+        self._node_logger = NodeLogger(log_provider)
 
     def on_start(self):
 
@@ -515,7 +642,7 @@ class GraphProcessor(_actors.Actor):
             for node_id, node in graph.nodes.items():
                 if node_id in graph.succeeded_nodes and not self._is_required_node(node, graph):
                     node = processed_graph.nodes.pop(node_id)
-                    NodeLogger.log_node_evict(node)
+                    self._node_logger.log_node_evict(node)
                     del node
 
             pending_nodes = cp.copy(graph.pending_nodes)
@@ -540,13 +667,13 @@ class GraphProcessor(_actors.Actor):
                     # There is scope for a much more sophisticated approach, with prioritized scheduling
 
                     if isinstance(node.node, _graph.ChildJobNode):
-                        processor = ChildJobNodeProcessor(processed_graph, node)
+                        processor = ChildJobNodeProcessor(processed_graph, node, self._node_logger)
                     elif isinstance(node.node, _graph.RunModelNode) or isinstance(node.node, _graph.ImportModelNode):
-                        processor = ModelNodeProcessor(processed_graph, node)
+                        processor = ModelNodeProcessor(processed_graph, node, self._node_logger)
                     elif isinstance(node.node, _graph.LoadDataNode) or isinstance(node.node, _graph.SaveDataNode):
-                        processor = DataNodeProcessor(processed_graph, node)
+                        processor = DataNodeProcessor(processed_graph, node, self._node_logger)
                     else:
-                        processor = NodeProcessor(processed_graph, node)
+                        processor = NodeProcessor(processed_graph, node, self._node_logger)
 
                     # New nodes can be launched with the updated graph
                     # Anything that was pruned is not needed by the new node
@@ -614,7 +741,7 @@ class GraphProcessor(_actors.Actor):
         new_graph.pending_nodes = cp.copy(new_graph.pending_nodes)
 
         for node_id, node in new_nodes.items():
-            GraphLogger.log_node_add(node)
+            self._graph_logger.log_node_add(node)
             node_func = self._resolver.resolve_node(node)
             new_node = _EngineNode(node, node_func)
             new_graph.nodes[node_id] = new_node
@@ -624,7 +751,7 @@ class GraphProcessor(_actors.Actor):
             engine_node = cp.copy(new_graph.nodes[node_id])
             engine_node.dependencies = cp.copy(engine_node.dependencies)
             for dep in deps:
-                GraphLogger.log_dependency_add(node_id, dep.node_id)
+                self._graph_logger.log_dependency_add(node_id, dep.node_id)
                 engine_node.dependencies[dep.node_id] = dep.dependency_type
             new_graph.nodes[node_id] = engine_node
 
@@ -784,11 +911,12 @@ class NodeProcessor(_actors.Actor):
 
     __NONE_TYPE = type(None)
 
-    def __init__(self, graph: _EngineContext, node: _EngineNode):
+    def __init__(self, graph: _EngineContext, node: _EngineNode, node_logger: "NodeLogger"):
         super().__init__()
         self.graph = graph
         self.node = node
         self.node_id = node.node.id
+        self.node_logger = node_logger
 
 
     def on_start(self):
@@ -823,7 +951,7 @@ class NodeProcessor(_actors.Actor):
 
         try:
 
-            NodeLogger.log_node_start(self.node)
+            self.node_logger.log_node_start(self.node)
 
             # Context contains only node states available when the context is set up
             ctx = NodeContextImpl(self.graph.nodes)
@@ -836,13 +964,13 @@ class NodeProcessor(_actors.Actor):
 
             self._check_result_type(result)
 
-            NodeLogger.log_node_succeeded(self.node)
+            self.node_logger.log_node_succeeded(self.node)
 
             self.actors().send_parent("node_succeeded", self.node_id, result)
 
         except Exception as e:
 
-            NodeLogger.log_node_failed(self.node, e)
+            self.node_logger.log_node_failed(self.node, e)
 
             self.actors().send_parent("node_failed", self.node_id, e)
 
@@ -898,28 +1026,29 @@ class NodeProcessor(_actors.Actor):
 
 class ModelNodeProcessor(NodeProcessor):
 
-    def __init__(self, graph: _EngineContext, node: _EngineNode):
-        super().__init__(graph, node)
+    def __init__(self, graph: _EngineContext, node: _EngineNode, node_logger: "NodeLogger"):
+        super().__init__(graph, node, node_logger)
 
 
 class DataNodeProcessor(NodeProcessor):
 
-    def __init__(self, graph: _EngineContext, node: _EngineNode):
-        super().__init__(graph, node)
+    def __init__(self, graph: _EngineContext, node: _EngineNode, node_logger: "NodeLogger"):
+        super().__init__(graph, node, node_logger)
 
 
 class ChildJobNodeProcessor(NodeProcessor):
 
-    def __init__(self, graph: _EngineContext, node: _EngineNode):
-        super().__init__(graph, node)
+    def __init__(self, graph: _EngineContext, node: _EngineNode, node_logger: "NodeLogger"):
+        super().__init__(graph, node, node_logger)
 
     @_actors.Message
     def evaluate_node(self):
 
-        NodeLogger.log_node_start(self.node)
+        self.node_logger.log_node_start(self.node)
 
         job_id = self.node.node.job_id  # noqa
         job_key = _util.object_key(job_id)
+        parent_key = self.graph.job_key
 
         node_id = self.actors().id
 
@@ -934,21 +1063,21 @@ class ChildJobNodeProcessor(NodeProcessor):
 
         graph_spec: _graph.Graph = self.node.node.graph  # noqa
 
-        self.actors().send(self.graph.engine_id, "submit_child_job", job_id, graph_spec, monitor_id)
+        self.actors().send(self.graph.engine_id, "submit_child_job", parent_key, job_id, graph_spec, monitor_id)
 
     @_actors.Message
     def child_job_succeeded(self, job_result: _cfg.JobResult):
 
         self._check_result_type(job_result)
 
-        NodeLogger.log_node_succeeded(self.node)
+        self.node_logger.log_node_succeeded(self.node)
 
         self.actors().send_parent("node_succeeded", self.node_id, job_result)
 
     @_actors.Message
     def child_job_failed(self, job_error: Exception):
 
-        NodeLogger.log_node_failed(self.node, job_error)
+        self.node_logger.log_node_failed(self.node, job_error)
 
         self.actors().send_parent("node_failed", self.node_id, job_error)
 
@@ -959,23 +1088,22 @@ class GraphLogger:
     Log the activity of the GraphProcessor
     """
 
-    _log = _util.logger_for_class(GraphProcessor)
+    def __init__(self, log_provider: _logging.LogProvider):
+        self._log = log_provider.logger_for_class(GraphProcessor)
 
-    @classmethod
-    def log_node_add(cls, node: _graph.Node):
+    def log_node_add(self, node: _graph.Node):
 
         node_name = node.id.name
         namespace = node.id.namespace
 
-        cls._log.info(f"ADD {cls._func_type(node)} [{node_name}] / {namespace}")
+        self._log.info(f"ADD {self._func_type(node)} [{node_name}] / {namespace}")
 
-    @classmethod
-    def log_dependency_add(cls, node_id: NodeId, dep_id: NodeId):
+    def log_dependency_add(self, node_id: NodeId, dep_id: NodeId):
 
         if node_id.namespace == dep_id.namespace:
-            cls._log.info(f"ADD DEPENDENCY [{node_id.name}] -> [{dep_id.name}] / {node_id.namespace}")
+            self._log.info(f"ADD DEPENDENCY [{node_id.name}] -> [{dep_id.name}] / {node_id.namespace}")
         else:
-            cls._log.info(f"ADD DEPENDENCY [{node_id.name}] / {node_id.namespace} -> [{dep_id.name}] / {dep_id.namespace}")
+            self._log.info(f"ADD DEPENDENCY [{node_id.name}] / {node_id.namespace} -> [{dep_id.name}] / {dep_id.namespace}")
 
     @classmethod
     def _func_type(cls, node: _graph.Node):
@@ -992,7 +1120,8 @@ class NodeLogger:
 
     # Separate out the logic for logging nodes, so the NodeProcessor itself stays a bit cleaner
 
-    _log = _util.logger_for_class(NodeProcessor)
+    def __init__(self, log_provider: _logging.LogProvider):
+        self._log = log_provider.logger_for_class(NodeProcessor)
 
     class LoggingType(enum.Enum):
         DEFAULT = 0
@@ -1001,81 +1130,75 @@ class NodeLogger:
         SIMPLE_MAPPING = 3
         MODEL = 4
 
-    @classmethod
-    def log_node_start(cls, node: _EngineNode):
+    def log_node_start(self, node: _EngineNode):
 
-        logging_type = cls._logging_type(node)
+        logging_type = self._logging_type(node)
         node_name = node.node.id.name
         namespace = node.node.id.namespace
 
-        if logging_type == cls.LoggingType.STATIC_VALUE:
-            cls._log.info(f"SET {cls._value_type(node)} [{node_name}] / {namespace}")
+        if logging_type == self.LoggingType.STATIC_VALUE:
+            self._log.info(f"SET {self._value_type(node)} [{node_name}] / {namespace}")
 
-        elif logging_type in [cls.LoggingType.SIMPLE_MAPPING]:
-            cls._log.info(f"MAP {cls._value_type(node)} [{cls._mapping_source(node)}] -> [{node_name}] / {namespace}")
+        elif logging_type in [self.LoggingType.SIMPLE_MAPPING]:
+            self._log.info(f"MAP {self._value_type(node)} [{self._mapping_source(node)}] -> [{node_name}] / {namespace}")
 
         else:
-            cls._log.info(f"START {cls._func_type(node)} [{node_name}] / {namespace}")
+            self._log.info(f"START {self._func_type(node)} [{node_name}] / {namespace}")
 
-    @classmethod
-    def log_node_succeeded(cls, node: _EngineNode):
+    def log_node_succeeded(self, node: _EngineNode):
 
-        logging_type = cls._logging_type(node)
+        logging_type = self._logging_type(node)
         node_name = node.node.id.name
         namespace = node.node.id.namespace
 
-        if logging_type in [cls.LoggingType.STATIC_VALUE, cls.LoggingType.SIMPLE_MAPPING]:
+        if logging_type in [self.LoggingType.STATIC_VALUE, self.LoggingType.SIMPLE_MAPPING]:
             return
 
-        if logging_type == cls.LoggingType.PUSH_POP:
-            cls._log_push_pop_node_details(node.node)  # noqa
+        if logging_type == self.LoggingType.PUSH_POP:
+            self._log_push_pop_node_details(node.node)  # noqa
 
-        if logging_type == cls.LoggingType.MODEL:
-            cls._log_model_node_details(node.node)  # noqa
+        if logging_type == self.LoggingType.MODEL:
+            self._log_model_node_details(node.node)  # noqa
 
-        cls._log.info(f"DONE {cls._func_type(node)} [{node_name}] / {namespace}")
+        self._log.info(f"DONE {self._func_type(node)} [{node_name}] / {namespace}")
 
-    @classmethod
-    def log_node_failed(cls, node: _EngineNode, e: Exception):
+    def log_node_failed(self, node: _EngineNode, e: Exception):
 
         node_name = node.node.id.name
         namespace = node.node.id.namespace
 
-        cls._log.error(f"FAILED {cls._func_type(node)} [{node_name}] / {namespace}")
-        cls._log.exception(e)
+        self._log.error(f"FAILED {self._func_type(node)} [{node_name}] / {namespace}")
+        self._log.exception(e)
 
-    @classmethod
-    def log_node_evict(cls, node: _EngineNode):
+    def log_node_evict(self, node: _EngineNode):
 
-        logging_type = cls._logging_type(node)
+        logging_type = self._logging_type(node)
         node_name = node.node.id.name
         namespace = node.node.id.namespace
 
-        if logging_type in [cls.LoggingType.STATIC_VALUE, cls.LoggingType.SIMPLE_MAPPING]:
+        if logging_type in [self.LoggingType.STATIC_VALUE, self.LoggingType.SIMPLE_MAPPING]:
             return
 
-        cls._log.info(f"EVICT {cls._func_type(node)} [{node_name}] / {namespace}")
+        self._log.info(f"EVICT {self._func_type(node)} [{node_name}] / {namespace}")
 
-    @classmethod
-    def _log_push_pop_node_details(cls, node: tp.Union[_graph.ContextPushNode, _graph.ContextPopNode]):
+    def _log_push_pop_node_details(self, node: tp.Union[_graph.ContextPushNode, _graph.ContextPopNode]):
 
         push_or_pop = "PUSH" if isinstance(node, _graph.ContextPushNode) else "POP"
         direction = "->" if isinstance(node, _graph.ContextPushNode) else "<-"
 
         for inner_id, outer_id in node.mapping.items():
-            item_type = cls._type_str(inner_id.result_type)
+            item_type = self._type_str(inner_id.result_type)
             msg = f"{push_or_pop} {item_type} [{outer_id.name}] {direction} [{inner_id.name}] / {node.id.namespace}"
-            cls._log.info(msg)
+            self._log.info(msg)
 
-    @classmethod
-    def _log_model_node_details(cls, node: _graph.RunModelNode):
+    def _log_model_node_details(self, node: _graph.RunModelNode):
 
-        cls._type_str(_data.DataView)
+        self._type_str(_data.DataView)
 
         for output in node.model_def.outputs:
-            result_type = cls._type_str(_data.DataView)
+            result_type = self._type_str(_data.DataView)
             msg = f"RESULT {result_type} [{output}] / {node.bundle_namespace}"
-            cls._log.info(msg)
+            self._log.info(msg)
 
     @classmethod
     def _logging_type(cls, node: _EngineNode) -> LoggingType: