ddeutil-workflow 0.0.84__py3-none-any.whl → 0.0.86__py3-none-any.whl

ddeutil/workflow/traces.py

@@ -17,6 +17,7 @@ Functions:
     set_logging: Configure logger with custom formatting.
     get_trace: Factory function for trace instances.
 """
+import contextlib
 import json
 import logging
 import os
@@ -38,6 +39,7 @@ from typing import (
     Optional,
     TypeVar,
     Union,
+    cast,
 )
 from zoneinfo import ZoneInfo
 
@@ -56,7 +58,12 @@ EMJ_SKIP: str = "⏭️"
 
 
 @lru_cache
-def set_logging(name: str) -> logging.Logger:
+def set_logging(
+    name: str,
+    *,
+    message_fmt: Optional[str] = None,
+    datetime_fmt: Optional[str] = None,
+) -> logging.Logger:
     """Configure logger with custom formatting and handlers.
 
     Creates and configures a logger instance with the custom formatter and
@@ -64,7 +71,9 @@ def set_logging(name: str) -> logging.Logger:
     console output and proper formatting for workflow execution tracking.
 
     Args:
-        name: Module name to create logger for.
+        name (str): A module name to create logger for.
+        message_fmt: (str, default None)
+        datetime_fmt: (str, default None)
 
     Returns:
         logging.Logger: Configured logger instance with custom formatting.
@@ -81,9 +90,9 @@ def set_logging(name: str) -> logging.Logger:
     #   `logging.getLogger('ddeutil.workflow').propagate = False`
     #
     _logger.addHandler(logging.NullHandler())
-
     formatter = logging.Formatter(
-        fmt=config.log_format, datefmt=config.log_datetime_format
+        fmt=message_fmt,
+        datefmt=datetime_fmt,
     )
     stream_handler = logging.StreamHandler()
     stream_handler.setFormatter(formatter)
@@ -92,22 +101,34 @@ def set_logging(name: str) -> logging.Logger:
     return _logger
 
 
+PrefixType = Literal[
+    "caller",
+    "nested",
+    "stage",
+    "job",
+    "workflow",
+    "release",
+    "schedule",
+    "audit",
+]
 PREFIX_LOGS: Final[dict[str, dict]] = {
-    "CALLER": {
+    "caller": {
         "emoji": "⚙️",
         "desc": "logs from any usage from custom caller function.",
     },
-    "NESTED": {"emoji": "⛓️", "desc": "logs from stages module."},
-    "STAGE": {"emoji": "🔗", "desc": "logs from stages module."},
-    "JOB": {"emoji": "🏗", "desc": "logs from job module."},
-    "WORKFLOW": {"emoji": "👟", "desc": "logs from workflow module."},
-    "RELEASE": {"emoji": "📅", "desc": "logs from release workflow method."},
-    "POKING": {"emoji": "⏰", "desc": "logs from poke workflow method."},
-    "AUDIT": {"emoji": "📌", "desc": "logs from audit model."},
+    "nested": {"emoji": "⛓️", "desc": "logs from stages module."},
+    "stage": {"emoji": "🔗", "desc": "logs from stages module."},
+    "job": {"emoji": "🏗", "desc": "logs from job module."},
+    "workflow": {"emoji": "👟", "desc": "logs from workflow module."},
+    "release": {"emoji": "📅", "desc": "logs from release workflow method."},
+    "schedule": {"emoji": "⏰", "desc": "logs from poke workflow method."},
+    "audit": {"emoji": "📌", "desc": "logs from audit model."},
 }  # pragma: no cov
-PREFIX_DEFAULT: Final[str] = "CALLER"
+PREFIX_LOGS_UPPER: Final[Iterator[str]] = (p.upper() for p in PREFIX_LOGS)
+PREFIX_DEFAULT: Final[Literal["caller"]] = "caller"
+PREFIX_EMOJI_DEFAULT: Final[str] = "⚙️"
 PREFIX_LOGS_REGEX: Final[re.Pattern[str]] = re.compile(
-    rf"(^\[(?P<name>{'|'.join(PREFIX_LOGS)})]:\s?)?(?P<message>.*)",
+    rf"(^\[(?P<module>{'|'.join(PREFIX_LOGS_UPPER)})]:\s?)?(?P<message>.*)",
     re.MULTILINE | re.DOTALL | re.ASCII | re.VERBOSE,
 )  # pragma: no cov
 
@@ -119,42 +140,58 @@ class Message(BaseModel):
     with emoji support and categorization.
     """
 
-    name: Optional[str] = Field(
-        default=None, description="A prefix name of message."
+    module: Optional[PrefixType] = Field(
+        default=None,
+        description="A prefix module of message it allow to be None.",
     )
     message: Optional[str] = Field(default=None, description="A message.")
 
+    @field_validator("module", mode="before", json_schema_input_type=str)
+    def __prepare_module(cls, data: Optional[str]) -> Optional[str]:
+        return data.lower() if data is not None else data
+
     @classmethod
-    def from_str(cls, msg: str) -> Self:
+    def from_str(cls, msg: str, module: Optional[PrefixType] = None) -> Self:
         """Extract message prefix from an input message.
 
         Args:
-            msg: A message that want to extract.
+            msg (str): A message that want to extract.
+            module (PrefixType, default None): A prefix module type.
 
         Returns:
             Message: The validated model from a string message.
         """
-        return Message.model_validate(
-            obj=PREFIX_LOGS_REGEX.search(msg).groupdict()
-        )
+        msg = cls.model_validate(PREFIX_LOGS_REGEX.search(msg).groupdict())
+        if msg.module is None and module:
+            msg.module = module
+        return msg
 
     def prepare(self, extras: Optional[DictData] = None) -> str:
         """Prepare message with force add prefix before writing trace log.
 
         Args:
-            extras: An extra parameter that want to get the
-                `log_add_emoji` flag.
+            extras (DictData, default None): An extra parameter that want to
+                get the `log_add_emoji` flag.
 
         Returns:
             str: The prepared message with prefix and optional emoji.
         """
-        name: str = self.name or PREFIX_DEFAULT
+        module = cast(PrefixType, self.module or PREFIX_DEFAULT)
+        module_data: dict[str, str] = PREFIX_LOGS.get(
+            module, {"emoji": PREFIX_EMOJI_DEFAULT}
+        )
         emoji: str = (
-            f"{PREFIX_LOGS[name]['emoji']} "
+            f"{module_data['emoji']} "
             if (extras or {}).get("log_add_emoji", True)
             else ""
         )
-        return f"{emoji}[{name}]: {self.message}"
+        return f"{emoji}[{module.upper()}]: {self.message}"
+
+
+class Metric(BaseModel):  # pragma: no cov
+    """Trace Metric model that will validate data from current logging."""
+
+    execution_time: float
 
 
 class Metadata(BaseModel):  # pragma: no cov
@@ -172,6 +209,9 @@ class Metadata(BaseModel):  # pragma: no cov
     )
     process: int = Field(description="A process ID.")
     thread: int = Field(description="A thread ID.")
+    module: Optional[PrefixType] = Field(
+        default=None, description="A prefix module type."
+    )
     message: str = Field(description="A message log.")
     cut_id: Optional[str] = Field(
         default=None, description="A cutting of running ID."
@@ -181,17 +221,6 @@ class Metadata(BaseModel):  # pragma: no cov
     filename: str = Field(description="A filename of this log.")
     lineno: int = Field(description="A line number of this log.")
 
-    # Enhanced observability fields
-    workflow_name: Optional[str] = Field(
-        default=None, description="Name of the workflow being executed."
-    )
-    stage_name: Optional[str] = Field(
-        default=None, description="Name of the current stage being executed."
-    )
-    job_name: Optional[str] = Field(
-        default=None, description="Name of the current job being executed."
-    )
-
     # Performance metrics
     duration_ms: Optional[float] = Field(
         default=None, description="Execution duration in milliseconds."
@@ -203,44 +232,6 @@ class Metadata(BaseModel):  # pragma: no cov
         default=None, description="CPU usage percentage at log time."
     )
 
-    # Distributed tracing support
-    trace_id: Optional[str] = Field(
-        default=None,
-        description="OpenTelemetry trace ID for distributed tracing.",
-    )
-    span_id: Optional[str] = Field(
-        default=None,
-        description="OpenTelemetry span ID for distributed tracing.",
-    )
-    parent_span_id: Optional[str] = Field(
-        default=None, description="Parent span ID for correlation."
-    )
-
-    # Error context
-    exception_type: Optional[str] = Field(
-        default=None, description="Exception class name if error occurred."
-    )
-    exception_message: Optional[str] = Field(
-        default=None, description="Exception message if error occurred."
-    )
-    stack_trace: Optional[str] = Field(
-        default=None, description="Full stack trace if error occurred."
-    )
-    error_code: Optional[str] = Field(
-        default=None, description="Custom error code for categorization."
-    )
-
-    # Business context
-    user_id: Optional[str] = Field(
-        default=None, description="User ID who triggered the workflow."
-    )
-    tenant_id: Optional[str] = Field(
-        default=None, description="Tenant ID for multi-tenant environments."
-    )
-    environment: Optional[str] = Field(
-        default=None, description="Environment (dev, staging, prod)."
-    )
-
     # NOTE: System context
     hostname: Optional[str] = Field(
         default=None, description="Hostname where workflow is running."
@@ -259,7 +250,7 @@ class Metadata(BaseModel):  # pragma: no cov
     tags: Optional[list[str]] = Field(
         default_factory=list, description="Custom tags for categorization."
     )
-    metadata: Optional[DictData] = Field(
+    metric: Optional[DictData] = Field(
         default_factory=dict, description="Additional custom metadata."
     )
 
@@ -299,6 +290,8 @@ class Metadata(BaseModel):  # pragma: no cov
         run_id: str,
         parent_run_id: Optional[str],
         *,
+        metric: Optional[DictData] = None,
+        module: Optional[PrefixType] = None,
         extras: Optional[DictData] = None,
     ) -> Self:
         """Make the current metric for contract this Metadata model instance.
@@ -313,6 +306,8 @@ class Metadata(BaseModel):  # pragma: no cov
             cutting_id: A cutting ID string.
             run_id:
             parent_run_id:
+            metric:
+            module:
             extras: An extra parameter that want to override core
                 config values.
 
@@ -357,33 +352,17 @@ class Metadata(BaseModel):  # pragma: no cov
             ),
             process=os.getpid(),
             thread=get_ident(),
+            module=module,
             message=message,
             cut_id=cutting_id,
             run_id=run_id,
             parent_run_id=parent_run_id,
             filename=frame_info.filename.split(os.path.sep)[-1],
             lineno=frame_info.lineno,
-            # NOTE: Enhanced observability fields
-            workflow_name=extras_data.get("workflow_name"),
-            stage_name=extras_data.get("stage_name"),
-            job_name=extras_data.get("job_name"),
             # NOTE: Performance metrics
             duration_ms=extras_data.get("duration_ms"),
             memory_usage_mb=extras_data.get("memory_usage_mb"),
             cpu_usage_percent=extras_data.get("cpu_usage_percent"),
-            # NOTE: Distributed tracing support
-            trace_id=extras_data.get("trace_id"),
-            span_id=extras_data.get("span_id"),
-            parent_span_id=extras_data.get("parent_span_id"),
-            # NOTE: Error context
-            exception_type=extras_data.get("exception_type"),
-            exception_message=extras_data.get("exception_message"),
-            stack_trace=extras_data.get("stack_trace"),
-            error_code=extras_data.get("error_code"),
-            # NOTE: Business context
-            user_id=extras_data.get("user_id"),
-            tenant_id=extras_data.get("tenant_id"),
-            environment=extras_data.get("environment"),
             # NOTE: System context
             hostname=hostname,
             ip_address=ip_address,
@@ -391,11 +370,17 @@ class Metadata(BaseModel):  # pragma: no cov
             package_version=__version__,
             # NOTE: Custom metadata
             tags=extras_data.get("tags", []),
-            metadata=extras_data.get("metadata", {}),
+            metric=metric,
         )
 
     @property
-    def pointer_id(self):
+    def pointer_id(self) -> str:
+        """Pointer ID of trace metadata.
+
+        Returns:
+            str: A pointer ID that will choose from parent running ID or running
+                ID.
+        """
         return self.parent_run_id or self.run_id
 
 
@@ -449,6 +434,27 @@ class ConsoleHandler(BaseHandler):
     """Console Handler model."""
 
     type: Literal["console"] = "console"
+    name: str = "ddeutil.workflow"
+    format: str = Field(
+        default=(
+            "%(asctime)s.%(msecs)03d (%(process)-5d, "
+            "%(thread)-5d) [%(levelname)-7s] (%(cut_id)s) %(message)-120s "
+            "(%(filename)s:%(lineno)s) (%(name)-10s)"
+        ),
+        description="A log format that will use with logging package.",
+    )
+    datetime_format: str = Field(
+        default="%Y-%m-%d %H:%M:%S",
+        description="A log datetime format.",
+    )
+
+    def pre(self) -> None:
+        """Pre-process."""
+        set_logging(
+            self.name,
+            message_fmt=self.format,
+            datetime_fmt=self.datetime_format,
+        )
 
     def emit(
         self, metadata: Metadata, *, extra: Optional[DictData] = None
@@ -512,6 +518,9 @@ class FileHandler(BaseHandler):
         return log_file
 
     def pre(self) -> None:  # pragma: no cov
+        """Pre-method that will call from getting trace model factory function.
+        This method will create filepath of this parent log.
+        """
         if not (p := Path(self.path)).exists():
             p.mkdir(parents=True)
 
@@ -521,7 +530,12 @@ class FileHandler(BaseHandler):
         *,
         extra: Optional[DictData] = None,
     ) -> None:
-        """Emit trace log."""
+        """Emit trace log to the file with a specific pointer path.
+
+        Args:
+            metadata (Metadata):
+            extra (DictData, default None):
+        """
         pointer: Path = self.pointer(metadata.pointer_id)
         std_file = "stderr" if metadata.error_flag else "stdout"
         with self._lock:
@@ -541,6 +555,7 @@ class FileHandler(BaseHandler):
         *,
         extra: Optional[DictData] = None,
     ) -> None:  # pragma: no cove
+        """Async emit trace log."""
         try:
             import aiofiles
         except ImportError as e:
@@ -717,22 +732,9 @@ class SQLiteHandler(BaseHandler):  # pragma: no cov
                         filename TEXT NOT NULL,
                         lineno INTEGER NOT NULL,
                         cut_id TEXT,
-                        workflow_name TEXT,
-                        stage_name TEXT,
-                        job_name TEXT,
                         duration_ms REAL,
                         memory_usage_mb REAL,
                         cpu_usage_percent REAL,
-                        trace_id TEXT,
-                        span_id TEXT,
-                        parent_span_id TEXT,
-                        exception_type TEXT,
-                        exception_message TEXT,
-                        stack_trace TEXT,
-                        error_code TEXT,
-                        user_id TEXT,
-                        tenant_id TEXT,
-                        environment TEXT,
                         hostname TEXT,
                         ip_address TEXT,
                         python_version TEXT,
@@ -938,28 +940,15 @@ class SQLiteHandler(BaseHandler):  # pragma: no cov
                             cut_id=record[11],
                             filename=record[9],
                             lineno=record[10],
-                            workflow_name=record[12],
-                            stage_name=record[13],
-                            job_name=record[14],
                             duration_ms=record[15],
                             memory_usage_mb=record[16],
                             cpu_usage_percent=record[17],
-                            trace_id=record[18],
-                            span_id=record[19],
-                            parent_span_id=record[20],
-                            exception_type=record[21],
-                            exception_message=record[22],
-                            stack_trace=record[23],
-                            error_code=record[24],
-                            user_id=record[25],
-                            tenant_id=record[26],
-                            environment=record[27],
                             hostname=record[28],
                             ip_address=record[29],
                             python_version=record[30],
                             package_version=record[31],
                             tags=json.loads(record[32]) if record[32] else [],
-                            metadata=(
+                            metric=(
                                 json.loads(record[33]) if record[33] else {}
                             ),
                         )
@@ -1045,28 +1034,15 @@ class SQLiteHandler(BaseHandler):  # pragma: no cov
                         cut_id=record[11],
                         filename=record[9],
                         lineno=record[10],
-                        workflow_name=record[12],
-                        stage_name=record[13],
-                        job_name=record[14],
                         duration_ms=record[15],
                         memory_usage_mb=record[16],
                         cpu_usage_percent=record[17],
-                        trace_id=record[18],
-                        span_id=record[19],
-                        parent_span_id=record[20],
-                        exception_type=record[21],
-                        exception_message=record[22],
-                        stack_trace=record[23],
-                        error_code=record[24],
-                        user_id=record[25],
-                        tenant_id=record[26],
-                        environment=record[27],
                         hostname=record[28],
                         ip_address=record[29],
                         python_version=record[30],
                         package_version=record[31],
                         tags=json.loads(record[32]) if record[32] else [],
-                        metadata=json.loads(record[33]) if record[33] else {},
+                        metric=json.loads(record[33]) if record[33] else {},
                     )
 
                     meta_list.append(trace_meta)
@@ -1394,22 +1370,9 @@ class ElasticHandler(BaseHandler):  # pragma: no cov
                             "filename": {"type": "keyword"},
                             "lineno": {"type": "integer"},
                             "cut_id": {"type": "keyword"},
-                            "workflow_name": {"type": "keyword"},
-                            "stage_name": {"type": "keyword"},
-                            "job_name": {"type": "keyword"},
                             "duration_ms": {"type": "float"},
                             "memory_usage_mb": {"type": "float"},
                             "cpu_usage_percent": {"type": "float"},
-                            "trace_id": {"type": "keyword"},
-                            "span_id": {"type": "keyword"},
-                            "parent_span_id": {"type": "keyword"},
-                            "exception_type": {"type": "keyword"},
-                            "exception_message": {"type": "text"},
-                            "stack_trace": {"type": "text"},
-                            "error_code": {"type": "keyword"},
-                            "user_id": {"type": "keyword"},
-                            "tenant_id": {"type": "keyword"},
-                            "environment": {"type": "keyword"},
                             "hostname": {"type": "keyword"},
                             "ip_address": {"type": "ip"},
                             "python_version": {"type": "keyword"},
@@ -1453,22 +1416,9 @@ class ElasticHandler(BaseHandler):  # pragma: no cov
             "filename": base_data["filename"],
             "lineno": base_data["lineno"],
             "cut_id": base_data["cut_id"],
-            "workflow_name": base_data.get("workflow_name"),
-            "stage_name": base_data.get("stage_name"),
-            "job_name": base_data.get("job_name"),
             "duration_ms": base_data.get("duration_ms"),
             "memory_usage_mb": base_data.get("memory_usage_mb"),
             "cpu_usage_percent": base_data.get("cpu_usage_percent"),
-            "trace_id": base_data.get("trace_id"),
-            "span_id": base_data.get("span_id"),
-            "parent_span_id": base_data.get("parent_span_id"),
-            "exception_type": base_data.get("exception_type"),
-            "exception_message": base_data.get("exception_message"),
-            "stack_trace": base_data.get("stack_trace"),
-            "error_code": base_data.get("error_code"),
-            "user_id": base_data.get("user_id"),
-            "tenant_id": base_data.get("tenant_id"),
-            "environment": base_data.get("environment"),
             "hostname": base_data.get("hostname"),
             "ip_address": base_data.get("ip_address"),
             "python_version": base_data.get("python_version"),
@@ -1587,28 +1537,15 @@ class ElasticHandler(BaseHandler):  # pragma: no cov
                         cut_id=source.get("cut_id"),
                         filename=source["filename"],
                         lineno=source["lineno"],
-                        workflow_name=source.get("workflow_name"),
-                        stage_name=source.get("stage_name"),
-                        job_name=source.get("job_name"),
                         duration_ms=source.get("duration_ms"),
                         memory_usage_mb=source.get("memory_usage_mb"),
                         cpu_usage_percent=source.get("cpu_usage_percent"),
-                        trace_id=source.get("trace_id"),
-                        span_id=source.get("span_id"),
-                        parent_span_id=source.get("parent_span_id"),
-                        exception_type=source.get("exception_type"),
-                        exception_message=source.get("exception_message"),
-                        stack_trace=source.get("stack_trace"),
-                        error_code=source.get("error_code"),
-                        user_id=source.get("user_id"),
-                        tenant_id=source.get("tenant_id"),
-                        environment=source.get("environment"),
                         hostname=source.get("hostname"),
                         ip_address=source.get("ip_address"),
                         python_version=source.get("python_version"),
                         package_version=source.get("package_version"),
                         tags=source.get("tags", []),
-                        metadata=source.get("metadata", {}),
+                        metric=source.get("metric", {}),
                     )
 
                     meta_list.append(trace_meta)
@@ -1697,28 +1634,15 @@ class ElasticHandler(BaseHandler):  # pragma: no cov
                     cut_id=source.get("cut_id"),
                     filename=source["filename"],
                     lineno=source["lineno"],
-                    workflow_name=source.get("workflow_name"),
-                    stage_name=source.get("stage_name"),
-                    job_name=source.get("job_name"),
                     duration_ms=source.get("duration_ms"),
                     memory_usage_mb=source.get("memory_usage_mb"),
                     cpu_usage_percent=source.get("cpu_usage_percent"),
-                    trace_id=source.get("trace_id"),
-                    span_id=source.get("span_id"),
-                    parent_span_id=source.get("parent_span_id"),
-                    exception_type=source.get("exception_type"),
-                    exception_message=source.get("exception_message"),
-                    stack_trace=source.get("stack_trace"),
-                    error_code=source.get("error_code"),
-                    user_id=source.get("user_id"),
-                    tenant_id=source.get("tenant_id"),
-                    environment=source.get("environment"),
                     hostname=source.get("hostname"),
                     ip_address=source.get("ip_address"),
                     python_version=source.get("python_version"),
                     package_version=source.get("package_version"),
                     tags=source.get("tags", []),
-                    metadata=source.get("metadata", {}),
+                    metric=source.get("metric", {}),
                 )
 
                 meta_list.append(trace_meta)
@@ -1774,71 +1698,94 @@ class BaseEmit(ABC):
         self,
         msg: str,
         level: Level,
-    ):
+        *,
+        metric: Optional[DictData] = None,
+        module: Optional[PrefixType] = None,
+    ) -> None:
         """Write trace log with append mode and logging this message with any
         logging level.
 
         Args:
             msg: A message that want to log.
             level: A logging level.
+            metric (DictData, default None): A metric data that want to export
+                to each target handler.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
         raise NotImplementedError(
-            "Logging action should be implement for making trace log."
+            "Emit action should be implement for making trace log."
         )
 
-    def debug(self, msg: str):
+    def debug(self, msg: str, module: Optional[PrefixType] = None):
         """Write trace log with append mode and logging this message with the
         DEBUG level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        self.emit(msg, level="debug")
+        self.emit(msg, level="debug", module=module)
 
-    def info(self, msg: str) -> None:
+    def info(self, msg: str, module: Optional[PrefixType] = None) -> None:
         """Write trace log with append mode and logging this message with the
         INFO level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        self.emit(msg, level="info")
+        self.emit(msg, level="info", module=module)
 
-    def warning(self, msg: str) -> None:
+    def warning(self, msg: str, module: Optional[PrefixType] = None) -> None:
         """Write trace log with append mode and logging this message with the
         WARNING level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        self.emit(msg, level="warning")
+        self.emit(msg, level="warning", module=module)
 
-    def error(self, msg: str) -> None:
+    def error(self, msg: str, module: Optional[PrefixType] = None) -> None:
         """Write trace log with append mode and logging this message with the
         ERROR level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        self.emit(msg, level="error")
+        self.emit(msg, level="error", module=module)
 
-    def exception(self, msg: str) -> None:
+    def exception(self, msg: str, module: Optional[PrefixType] = None) -> None:
         """Write trace log with append mode and logging this message with the
         EXCEPTION level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        self.emit(msg, level="exception")
+        self.emit(msg, level="exception", module=module)
 
 
 class BaseAsyncEmit(ABC):
+    """Base Async Emit Abstract class for mixin `amit` method and async
+    logging that will use prefix with `a` charactor.
+    """
 
     @abstractmethod
     async def amit(
         self,
         msg: str,
         level: Level,
+        *,
+        metric: Optional[DictData] = None,
+        module: Optional[PrefixType] = None,
     ) -> None:
         """Async write trace log with append mode and logging this message with
         any logging level.
@@ -1846,55 +1793,79 @@ class BaseAsyncEmit(ABC):
         Args:
             msg (str): A message that want to log.
             level (Mode): A logging level.
+            metric (DictData, default None): A metric data that want to export
+                to each target handler.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
         raise NotImplementedError(
             "Async Logging action should be implement for making trace log."
         )
 
-    async def adebug(self, msg: str) -> None:  # pragma: no cov
+    async def adebug(
+        self, msg: str, module: Optional[PrefixType] = None
+    ) -> None:  # pragma: no cov
         """Async write trace log with append mode and logging this message with
         the DEBUG level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        await self.amit(msg, level="debug")
+        await self.amit(msg, level="debug", module=module)
 
-    async def ainfo(self, msg: str) -> None:  # pragma: no cov
+    async def ainfo(
+        self, msg: str, module: Optional[PrefixType] = None
+    ) -> None:  # pragma: no cov
         """Async write trace log with append mode and logging this message with
         the INFO level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        await self.amit(msg, level="info")
+        await self.amit(msg, level="info", module=module)
 
-    async def awarning(self, msg: str) -> None:  # pragma: no cov
+    async def awarning(
+        self, msg: str, module: Optional[PrefixType] = None
+    ) -> None:  # pragma: no cov
         """Async write trace log with append mode and logging this message with
         the WARNING level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        await self.amit(msg, level="warning")
+        await self.amit(msg, level="warning", module=module)
 
-    async def aerror(self, msg: str) -> None:  # pragma: no cov
+    async def aerror(
+        self, msg: str, module: Optional[PrefixType] = None
+    ) -> None:  # pragma: no cov
         """Async write trace log with append mode and logging this message with
         the ERROR level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        await self.amit(msg, level="error")
+        await self.amit(msg, level="error", module=module)
 
-    async def aexception(self, msg: str) -> None:  # pragma: no cov
+    async def aexception(
+        self, msg: str, module: Optional[PrefixType] = None
+    ) -> None:  # pragma: no cov
         """Async write trace log with append mode and logging this message with
         the EXCEPTION level.
 
         Args:
             msg: A message that want to log.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        await self.amit(msg, level="exception")
+        await self.amit(msg, level="exception", module=module)
 
 
 class Trace(BaseModel, BaseEmit, BaseAsyncEmit):
@@ -1940,35 +1911,41 @@ class Trace(BaseModel, BaseEmit, BaseAsyncEmit):
         cut_parent_run_id: str = cut_id(self.parent_run_id)
         return f"{cut_parent_run_id} -> {cut_run_id}"
 
-    def make_message(self, msg: str) -> str:
-        """Prepare and Make a message before write and log steps.
-
-        Args:
-            msg: A message that want to prepare and make before.
-
-        Returns:
-            str: The prepared message.
-        """
-        return prepare_newline(Message.from_str(msg).prepare(self.extras))
-
-    def emit(self, msg: str, level: Level) -> None:
+    def emit(
+        self,
+        msg: str,
+        level: Level,
+        *,
+        metric: Optional[DictData] = None,
+        module: Optional[PrefixType] = None,
+    ) -> None:
         """Emit a trace log to all handler. This will use synchronise process.
 
         Args:
             msg (str): A message.
             level (Level): A tracing level.
+            metric (DictData, default None): A metric data that want to export
+                to each target handler.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        _msg: str = self.make_message(msg)
+        _msg: Message = Message.from_str(msg, module=module)
         metadata: Metadata = Metadata.make(
             error_flag=(level in ("error", "exception")),
             level=level,
-            message=_msg,
+            module=_msg.module,
+            message=prepare_newline(_msg.prepare(self.extras)),
             cutting_id=self.cut_id,
             run_id=self.run_id,
             parent_run_id=self.parent_run_id,
+            metric=metric,
             extras=self.extras,
         )
+
+        # NOTE: Check enable buffer flag was set or not.
         if not self._enable_buffer:
+
+            # NOTE: Start emit tracing log data to each handler.
             for handler in self.handlers:
                 handler.emit(metadata, extra=self.extras)
             return
@@ -1981,56 +1958,76 @@ class Trace(BaseModel, BaseEmit, BaseAsyncEmit):
                 handler.flush(self._buffer, extra=self.extras)
             self._buffer.clear()
 
-    async def amit(self, msg: str, level: Level) -> None:
+    async def amit(
+        self,
+        msg: str,
+        level: Level,
+        *,
+        metric: Optional[DictData] = None,
+        module: Optional[PrefixType] = None,
+    ) -> None:
         """Async write trace log with append mode and logging this message with
         any logging level.
 
         Args:
             msg (str): A message that want to log.
             level (Level): A logging mode.
+            metric (DictData, default None): A metric data that want to export
+                to each target handler.
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
         """
-        _msg: str = self.make_message(msg)
+        _msg: Message = Message.from_str(msg, module=module)
         metadata: Metadata = Metadata.make(
             error_flag=(level in ("error", "exception")),
             level=level,
-            message=_msg,
+            module=_msg.module,
+            message=prepare_newline(_msg.prepare(self.extras)),
             cutting_id=self.cut_id,
             run_id=self.run_id,
             parent_run_id=self.parent_run_id,
+            metric=metric,
             extras=self.extras,
         )
+
+        # NOTE: Start emit tracing log data to each handler.
         for handler in self.handlers:
             await handler.amit(metadata, extra=self.extras)
 
-    def __enter__(self):
+    @contextlib.contextmanager
+    def buffer(self, module: Optional[PrefixType] = None) -> Iterator[Self]:
         """Enter the trace for catching the logs that run so fast. It will use
         buffer strategy to flush the logs instead emit.
+
+        Args:
+            module (PrefixType, default None): A module name that use for adding
+                prefix at the message value.
+
+        Yields:
+            Self: Itself instance.
         """
         self._enable_buffer = True
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit the trace that will clear all log in the buffer."""
-        if exc_type:
-            _msg: str = self.make_message(str(exc_val))
+        try:
+            yield self
+        except Exception as err:
+            _msg: Message = Message.from_str(str(err), module=module)
             metadata: Metadata = Metadata.make(
                 error_flag=True,
                 level="error",
-                message=_msg,
+                module=_msg.module,
+                message=prepare_newline(_msg.prepare(self.extras)),
                 cutting_id=self.cut_id,
                 run_id=self.run_id,
                 parent_run_id=self.parent_run_id,
                 extras=self.extras,
             )
             self._buffer.append(metadata)
-
-        if self._buffer:
-            for handler in self.handlers:
-                handler.flush(self._buffer, extra=self.extras)
-            self._buffer.clear()
-
-        # NOTE: Re-raise the exception if one occurred
-        return False
+            raise
+        finally:
+            if self._buffer:
+                for handler in self.handlers:
+                    handler.flush(self._buffer, extra=self.extras)
+                self._buffer.clear()
 
 
 def get_trace(
@@ -2039,38 +2036,39 @@ def get_trace(
     handlers: list[Union[DictData, Handler]] = None,
     parent_run_id: Optional[str] = None,
     extras: Optional[DictData] = None,
-    auto_pre_process: bool = False,
+    pre_process: bool = False,
 ) -> Trace:
-    """Get dynamic Trace instance from the core config.
+    """Get dynamic Trace instance from the core config. This function will use
+    for start some process, and it wants to generated trace object.
 
-    This factory function returns the appropriate trace implementation based on
-    configuration. It can be overridden by extras argument and accepts running ID
-    and parent running ID.
+        This factory function returns the appropriate trace implementation based
+    on configuration. It can be overridden by extras argument and accepts
+    running ID and parent running ID.
 
     Args:
         run_id (str): A running ID.
-        parent_run_id (str | None, default None): A parent running ID.
-        handlers (list):
-        extras: An extra parameter that want to override the core
-            config values.
-        auto_pre_process (bool, default False)
+        parent_run_id (str, default None): A parent running ID.
+        handlers (list[DictData | Handler], default None): A list of handler or
+            mapping of handler data that want to direct pass instead use
+            environment variable config.
+        extras (DictData, default None): An extra parameter that want to
+            override the core config values.
+        pre_process (bool, default False) A flag that will auto call pre
+            method after validate a trace model.
 
     Returns:
         Trace: The appropriate trace instance.
     """
-    handlers: list[DictData] = dynamic(
-        "trace_handlers", f=handlers, extras=extras
-    )
     trace: Trace = Trace.model_validate(
         {
             "run_id": run_id,
             "parent_run_id": parent_run_id,
-            "handlers": handlers,
+            "handlers": dynamic("trace_handlers", f=handlers, extras=extras),
             "extras": extras or {},
         }
     )
     # NOTE: Start pre-process when start create trace.
-    if auto_pre_process:
+    if pre_process:
         for handler in trace.handlers:
             handler.pre()
     return trace