cmdx 1.0.0 → 1.1.0

data/lib/cmdx/log_formatters/logstash.rb

@@ -2,72 +2,29 @@
 
 module CMDx
   module LogFormatters
-    # Logstash log formatter for CMDx logging system.
+    # Logstash log formatter that outputs structured log entries in Logstash JSON format.
     #
-    # Formats log entries as JSON objects compatible with Logstash and the ELK stack
-    # (Elasticsearch, Logstash, Kibana). Includes Logstash-specific fields like
-    # @version and @timestamp for seamless integration with log aggregation pipelines.
-    #
-    # @example Basic usage with global logger configuration
-    #   CMDx.configure do |config|
-    #     config.logger = Logger.new($stdout, formatter: CMDx::LogFormatters::Logstash.new)
-    #   end
-    #
-    # @example Task-specific formatter configuration for ELK stack
-    #   class ProcessOrderTask < CMDx::Task
-    #     task_settings!(log_format: CMDx::LogFormatters::Logstash.new)
-    #
-    #     def call
-    #       logger.info "Processing order #{order_id}"
-    #     end
-    #   end
-    #
-    # @example Sample Logstash JSON output
-    #   {"@version":"1","@timestamp":"2022-07-17T18:43:15.000000","severity":"INFO","pid":1234,"index":0,"chain_id":"018c2b95-b764-7615","type":"Task","class":"ProcessOrderTask","id":"018c2b95-b764-7615","tags":[],"state":"complete","status":"success","outcome":"success","metadata":{},"runtime":15,"origin":"CMDx"}
-    #
-    # @example Logstash configuration for CMDx logs
-    #   input {
-    #     file {
-    #       path => "/var/log/cmdx/*.log"
-    #       codec => "json"
-    #     }
-    #   }
-    #   filter {
-    #     if [origin] == "CMDx" {
-    #       # Process CMDx-specific fields
-    #     }
-    #   }
-    #
-    # @see CMDx::LogFormatters::Json For standard JSON formatting without Logstash fields
-    # @see CMDx::LoggerSerializer For details on serialized data structure
-    # @see https://www.elastic.co/guide/en/logstash/current/event-api.html Logstash Event API
+    # This formatter converts log entries into Logstash-compatible JSON format, including
+    # required Logstash fields such as @version and @timestamp, along with metadata
+    # such as severity and process ID. Each log entry is output as a single line of
+    # JSON followed by a newline character.
     class Logstash
 
       # Formats a log entry as a Logstash-compatible JSON string.
       #
-      # Creates a JSON object with Logstash-specific metadata fields (@version, @timestamp)
-      # combined with task execution data, severity, and process information for
-      # seamless integration with ELK stack log processing pipelines.
+      # @param severity [String] the log severity level (e.g., "INFO", "ERROR")
+      # @param time [Time] the timestamp when the log entry was created
+      # @param task [Object] the task object associated with the log entry
+      # @param message [String] the log message content
       #
-      # @param severity [String] Log severity level (DEBUG, INFO, WARN, ERROR, FATAL)
-      # @param time [Time] Timestamp when the log entry was created
-      # @param task [CMDx::Task] Task instance being logged
-      # @param message [Object] Log message or data to be included
+      # @return [String] the formatted Logstash JSON log entry with trailing newline
       #
-      # @return [String] Single-line Logstash-compatible JSON string with newline terminator
+      # @raise [JSON::GeneratorError] if the log data cannot be serialized to JSON
       #
-      # @example Success log entry for Logstash
+      # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::Logstash.new
-      #   output = formatter.call("INFO", Time.now, task, "Order processed")
-      #   # => {"@version":"1","@timestamp":"2022-07-17T18:43:15.000000","severity":"INFO",...}\n
-      #
-      # @example Error log entry with failure chain for ELK analysis
-      #   output = formatter.call("ERROR", Time.now, task, error_details)
-      #   # => {"@version":"1","severity":"ERROR","caused_failure":{...},"threw_failure":{...},...}\n
-      #
-      # @note The @version field is always set to "1" following Logstash conventions
-      # @note The @timestamp field uses ISO 8601 format for Elasticsearch compatibility
-      # @note All CMDx logs include an "origin" field set to "CMDx" for easy filtering
+      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
+      #   # => "{\"severity\":\"INFO\",\"pid\":12345,\"@version\":\"1\",\"@timestamp\":\"2024-01-01T12:00:00.000Z\",\"message\":\"Task completed\"}\n"
       def call(severity, time, task, message)
         m = LoggerSerializer.call(severity, time, task, message).merge!(
           severity:,

data/lib/cmdx/log_formatters/pretty_json.rb

@@ -2,65 +2,29 @@
 
 module CMDx
   module LogFormatters
-    # Pretty JSON log formatter for CMDx logging system.
+    # Pretty JSON log formatter that outputs structured log entries as formatted JSON.
     #
-    # Formats log entries as human-readable, multi-line JSON objects with proper
-    # indentation and formatting. Contains the same structured data as the JSON
-    # formatter but optimized for development environments and manual inspection.
-    #
-    # @example Basic usage with global logger configuration
-    #   CMDx.configure do |config|
-    #     config.logger = Logger.new($stdout, formatter: CMDx::LogFormatters::PrettyJson.new)
-    #   end
-    #
-    # @example Task-specific formatter configuration
-    #   class ProcessOrderTask < CMDx::Task
-    #     task_settings!(log_format: CMDx::LogFormatters::PrettyJson.new)
-    #
-    #     def call
-    #       logger.info "Processing order #{order_id}"
-    #     end
-    #   end
-    #
-    # @example Sample pretty JSON output
-    #   {
-    #     "severity": "INFO",
-    #     "pid": 1234,
-    #     "timestamp": "2022-07-17T18:43:15.000000",
-    #     "index": 0,
-    #     "chain_id": "018c2b95-b764-7615",
-    #     "type": "Task",
-    #     "class": "ProcessOrderTask",
-    #     "state": "complete",
-    #     "status": "success",
-    #     "outcome": "success"
-    #   }
-    #
-    # @see CMDx::LogFormatters::Json For compact single-line JSON formatting
-    # @see CMDx::LoggerSerializer For details on serialized data structure
+    # This formatter converts log entries into pretty-printed JSON format with proper
+    # indentation and line breaks, including metadata such as severity, process ID,
+    # and timestamp. Each log entry is output as a multi-line JSON structure followed
+    # by a newline character, making it human-readable while maintaining structure.
     class PrettyJson
 
       # Formats a log entry as a pretty-printed JSON string.
       #
-      # Combines task execution metadata with severity, process ID, and timestamp
-      # information to create a human-readable JSON log entry with proper
-      # indentation and formatting for development and debugging purposes.
+      # @param severity [String] the log severity level (e.g., "INFO", "ERROR")
+      # @param time [Time] the timestamp when the log entry was created
+      # @param task [Object] the task object associated with the log entry
+      # @param message [String] the log message content
       #
-      # @param severity [String] Log severity level (DEBUG, INFO, WARN, ERROR, FATAL)
-      # @param time [Time] Timestamp when the log entry was created
-      # @param task [CMDx::Task] Task instance being logged
-      # @param message [Object] Log message or data to be included
+      # @return [String] the formatted pretty JSON log entry with trailing newline
       #
-      # @return [String] Multi-line pretty-formatted JSON string with newline terminator
+      # @raise [JSON::GeneratorError] if the log data cannot be serialized to JSON
       #
-      # @example Success log entry
+      # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::PrettyJson.new
-      #   output = formatter.call("INFO", Time.now, task, "Order processed")
-      #   # => Multi-line formatted JSON output
-      #
-      # @example Error log entry with nested metadata
-      #   output = formatter.call("ERROR", Time.now, task, error_details)
-      #   # => Pretty-formatted JSON with nested failure information
+      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
+      #   # => "{\n  \"severity\": \"INFO\",\n  \"pid\": 12345,\n  \"timestamp\": \"2024-01-01T12:00:00Z\",\n  \"message\": \"Task completed\"\n}\n"
       def call(severity, time, task, message)
         m = LoggerSerializer.call(severity, time, task, message).merge!(
           severity:,

data/lib/cmdx/log_formatters/pretty_key_value.rb

@@ -2,59 +2,26 @@
 
 module CMDx
   module LogFormatters
-    # Pretty key-value log formatter for CMDx logging system.
+    # Pretty key-value log formatter that outputs structured log entries as human-readable key=value pairs.
     #
-    # Formats log entries as space-separated key=value pairs with ANSI color
-    # highlighting for improved readability in terminal environments. Provides
-    # the same structured data as KeyValue formatter with enhanced visual presentation.
-    #
-    # @example Basic usage with global logger configuration
-    #   CMDx.configure do |config|
-    #     config.logger = Logger.new($stdout, formatter: CMDx::LogFormatters::PrettyKeyValue.new)
-    #   end
-    #
-    # @example Task-specific formatter configuration
-    #   class ProcessOrderTask < CMDx::Task
-    #     task_settings!(log_format: CMDx::LogFormatters::PrettyKeyValue.new)
-    #
-    #     def call
-    #       logger.info "Processing order #{order_id}"
-    #     end
-    #   end
-    #
-    # @example Sample pretty key-value output (with ANSI colors)
-    #   severity=INFO pid=1234 timestamp=2022-07-17T18:43:15.000000 index=0 chain_id=018c2b95-b764-7615 type=Task class=ProcessOrderTask state=complete status=success outcome=success runtime=15
-    #   # Colors applied: severity levels, status values, class names, etc.
-    #
-    # @see CMDx::LogFormatters::KeyValue For plain key-value formatting without colors
-    # @see CMDx::LoggerAnsi For ANSI color definitions
-    # @see CMDx::LoggerSerializer For details on serialized data structure
+    # This formatter converts log entries into a space-separated key=value format with ANSI coloring
+    # for enhanced readability in terminal output. Each log entry includes metadata such as severity,
+    # process ID, and timestamp, with each entry terminated by a newline character.
     class PrettyKeyValue
 
-      # Formats a log entry as ANSI-colorized key=value pairs.
-      #
-      # Combines task execution metadata with severity, process ID, and timestamp
-      # information to create a visually enhanced key-value log entry with ANSI
-      # color codes for improved readability in terminal environments.
+      # Formats a log entry as a colorized key=value string.
       #
-      # @param severity [String] Log severity level (DEBUG, INFO, WARN, ERROR, FATAL)
-      # @param time [Time] Timestamp when the log entry was created
-      # @param task [CMDx::Task] Task instance being logged
-      # @param message [Object] Log message or data to be included
+      # @param severity [String] the log severity level (e.g., "INFO", "ERROR")
+      # @param time [Time] the timestamp when the log entry was created
+      # @param task [Object] the task object associated with the log entry
+      # @param message [String] the log message content
       #
-      # @return [String] Single-line ANSI-colorized key=value formatted string with newline terminator
+      # @return [String] the formatted key=value log entry with ANSI colors and trailing newline
       #
-      # @example Success log entry with colors
+      # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::PrettyKeyValue.new
-      #   output = formatter.call("INFO", Time.now, task, "Order processed")
-      #   # => ANSI-colored "severity=INFO pid=1234 ... status=success\n"
-      #
-      # @example Error log entry with colored failure indicators
-      #   output = formatter.call("ERROR", Time.now, task, error_details)
-      #   # => ANSI-colored "severity=ERROR ... status=failed\n" (red highlighting)
-      #
-      # @note ANSI colors are automatically applied to key elements like severity levels,
-      #   status values, class names, and metadata for enhanced visual distinction
+      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
+      #   # => "severity=INFO pid=12345 timestamp=2024-01-01T12:00:00Z message=Task completed\n"
       def call(severity, time, task, message)
         m = LoggerSerializer.call(severity, time, task, message, ansi_colorize: true).merge!(
           severity:,

data/lib/cmdx/log_formatters/pretty_line.rb

@@ -2,68 +2,30 @@
 
 module CMDx
   module LogFormatters
-    # Pretty line log formatter for CMDx logging system.
+    # Pretty line log formatter that outputs human-readable log entries with ANSI colors.
     #
-    # Formats log entries in a traditional single-line format enhanced with ANSI color
-    # highlighting for improved readability in terminal environments. Provides the same
-    # structured format as Line formatter with visual enhancements for severity levels,
-    # status indicators, and task information.
-    #
-    # @example Basic usage with global logger configuration
-    #   CMDx.configure do |config|
-    #     config.logger = Logger.new(STDOUT, formatter: CMDx::LogFormatters::PrettyLine.new)
-    #   end
-    #
-    # @example Task-specific formatter configuration
-    #   class ProcessOrderTask < CMDx::Task
-    #     task_settings!(log_format: CMDx::LogFormatters::PrettyLine.new)
-    #
-    #     def call
-    #       logger.info "Processing order #{order_id}"
-    #     end
-    #   end
-    #
-    # @example Sample pretty line output (with ANSI colors)
-    #   I, [2022-07-17T18:43:15.000000 #1234] INFO -- ProcessOrderTask: state=complete status=success outcome=success runtime=15
-    #   # Colors applied: INFO in blue, success in green, class name highlighted
-    #
-    # @example Error pretty line output with colored failure indicators
-    #   E, [2022-07-17T18:43:15.000000 #1234] ERROR -- ProcessOrderTask: state=interrupted status=failed outcome=failed
-    #   # Colors applied: ERROR in red, failed in red, class name highlighted
-    #
-    # @see CMDx::LogFormatters::Line For plain line formatting without colors
-    # @see CMDx::LoggerAnsi For ANSI color definitions
-    # @see CMDx::LoggerSerializer For details on serialized data structure
-    # @see CMDx::Utils::LogTimestamp For timestamp formatting
+    # This formatter converts log entries into a traditional log line format with
+    # color-coded severity levels, timestamps, and process information. The output
+    # is designed to be easily readable in terminal environments that support ANSI
+    # color codes.
     class PrettyLine
 
-      # Formats a log entry as an ANSI-colorized single-line log entry.
+      # Formats a log entry as a colorized human-readable line.
       #
-      # Creates a log entry in the format: "[COLORED_SEVERITY_INITIAL], [TIMESTAMP #PID] [COLORED_SEVERITY] -- CLASS: [COLORED_MESSAGE]"
-      # where colors are applied to severity indicators, status values, and other key elements.
+      # @param severity [String] the log severity level (e.g., "INFO", "ERROR")
+      # @param time [Time] the timestamp when the log entry was created
+      # @param task [Object] the task object associated with the log entry
+      # @param message [String] the log message content
       #
-      # @param severity [String] Log severity level (DEBUG, INFO, WARN, ERROR, FATAL)
-      # @param time [Time] Timestamp when the log entry was created
-      # @param task [CMDx::Task] Task instance being logged
-      # @param message [Object] Log message or data to be included
+      # @return [String] the formatted log line with ANSI colors and trailing newline
       #
-      # @return [String] Single-line ANSI-colorized log entry with newline terminator
+      # @raise [NoMethodError] if the task object doesn't respond to class or name methods
+      # @raise [StandardError] if LoggerSerializer, LoggerAnsi, or LogTimestamp fail
       #
-      # @example Success log entry with colors
+      # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::PrettyLine.new
-      #   output = formatter.call("INFO", Time.now, task, "Order processed")
-      #   # => ANSI-colored "I, [2022-07-17T18:43:15.000000 #1234] INFO -- ProcessOrderTask: state=complete status=success\n"
-      #
-      # @example Warning log entry with colored indicators
-      #   output = formatter.call("WARN", Time.now, task, "Order delayed")
-      #   # => ANSI-colored "W, [2022-07-17T18:43:15.000000 #1234] WARN -- ProcessOrderTask: state=interrupted status=skipped\n"
-      #
-      # @example Error log entry with red highlighting
-      #   output = formatter.call("ERROR", Time.now, task, error_details)
-      #   # => ANSI-colored "E, [2022-07-17T18:43:15.000000 #1234] ERROR -- ProcessOrderTask: status=failed caused_failure={...}\n"
-      #
-      # @note This is the default formatter for CMDx when no specific formatter is configured
-      # @note ANSI colors are automatically applied based on severity levels and status values
+      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
+      #   # => "\e[32mI\e[0m, [2024-01-01T12:00:00.000Z #12345] \e[32mINFO\e[0m -- MyTask: Task completed\n"
       def call(severity, time, task, message)
         i = LoggerAnsi.call(severity[0])
         s = LoggerAnsi.call(severity)

data/lib/cmdx/log_formatters/raw.rb

@@ -2,64 +2,34 @@
 
 module CMDx
   module LogFormatters
-    # Raw log formatter for CMDx logging system.
+    # Raw log formatter that outputs log messages using inspect format.
     #
-    # Outputs only the raw message content without any additional formatting,
-    # timestamps, severity indicators, or task metadata. Provides the simplest
-    # possible log output containing just the inspected message content.
-    #
-    # @example Basic usage with global logger configuration
-    #   CMDx.configure do |config|
-    #     config.logger = Logger.new($stdout, formatter: CMDx::LogFormatters::Raw.new)
-    #   end
-    #
-    # @example Task-specific formatter configuration
-    #   class ProcessOrderTask < CMDx::Task
-    #     task_settings!(log_format: CMDx::LogFormatters::Raw.new)
-    #
-    #     def call
-    #       logger.info "Processing order #{order_id}"
-    #       logger.debug({ order_details: order.attributes })
-    #     end
-    #   end
-    #
-    # @example Sample raw output
-    #   "Processing order 12345"
-    #   {:order_details=>{:id=>12345, :status=>"pending"}}
-    #
-    # @see CMDx::LogFormatters::Line For structured log formatting with metadata
-    # @see CMDx::LogFormatters::Json For JSON-formatted output
+    # This formatter provides a simple, unstructured log output by calling
+    # inspect on the message content. It ignores severity, time, and task
+    # metadata, focusing only on the raw message content. Each log entry
+    # is output as an inspected string followed by a newline character.
     class Raw
 
-      # Formats a log entry as raw message content only.
-      #
-      # Outputs only the message parameter using Ruby's inspect method,
-      # ignoring all other log context including severity, timestamp, and task information.
-      # Useful for debugging scenarios where only the message content is relevant.
+      # Formats a log entry as an inspected string.
       #
-      # @param _severity [String] Log severity level (ignored)
-      # @param _time [Time] Timestamp when the log entry was created (ignored)
-      # @param _task [CMDx::Task] Task instance being logged (ignored)
-      # @param message [Object] Log message or data to be output
+      # @param _severity [String] the log severity level (ignored)
+      # @param _time [Time] the timestamp when the log entry was created (ignored)
+      # @param _task [Object] the task object associated with the log entry (ignored)
+      # @param message [Object] the log message content to be inspected
       #
-      # @return [String] Raw message content with inspect formatting and newline terminator
+      # @return [String] the inspected message with trailing newline
       #
-      # @example String message output
+      # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::Raw.new
-      #   output = formatter.call("INFO", Time.now, task, "Order processed")
-      #   # => "\"Order processed\"\n"
+      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
+      #   # => "\"Task completed\"\n"
       #
-      # @example Hash message output
-      #   data = { order_id: 12345, status: "completed" }
-      #   output = formatter.call("DEBUG", Time.now, task, data)
-      #   # => "{:order_id=>12345, :status=>\"completed\"}\n"
-      #
-      # @example Array message output
-      #   items = ["item1", "item2", "item3"]
-      #   output = formatter.call("INFO", Time.now, task, items)
-      #   # => "[\"item1\", \"item2\", \"item3\"]\n"
+      # @example Formatting a complex object
+      #   formatter = CMDx::LogFormatters::Raw.new
+      #   result = formatter.call("DEBUG", Time.now, task_object, { status: :success, count: 42 })
+      #   # => "{:status=>:success, :count=>42}\n"
       def call(_severity, _time, _task, message)
-        message.inspect << "\n"
+        message.inspect + "\n" # rubocop:disable Style/StringConcatenation
       end
 
     end

data/lib/cmdx/logger.rb

@@ -1,101 +1,39 @@
 # frozen_string_literal: true
 
 module CMDx
-  # Logger configuration and setup module for CMDx tasks.
+  # Logger configuration and retrieval utilities for task execution.
   #
-  # The Logger module provides centralized logger configuration and initialization
-  # for CMDx tasks. It handles logger setup, formatter assignment, log level
-  # configuration, and progname assignment based on task settings.
-  #
-  # @example Basic logger usage
-  #   class ProcessOrderTask < CMDx::Task
-  #     def call
-  #       logger.info "Processing order #{order_id}"
-  #       logger.debug { "Order details: #{order.inspect}" }
-  #     end
-  #   end
-  #
-  # @example Task-specific logger configuration
-  #   class ProcessOrderTask < CMDx::Task
-  #     task_settings!(
-  #       logger: Rails.logger,
-  #       log_formatter: CMDx::LogFormatters::Json.new,
-  #       log_level: Logger::INFO
-  #     )
-  #   end
-  #
-  # @example Global logger configuration
-  #   CMDx.configure do |config|
-  #     config.logger = Logger.new($stdout)
-  #     config.log_formatter = CMDx::LogFormatters::PrettyLine.new
-  #     config.log_level = Logger::WARN
-  #   end
-  #
-  # @example Custom logger with specific formatter
-  #   logger = Logger.new(STDOUT)
-  #   logger.formatter = CMDx::LogFormatters::Logstash.new
-  #   logger.level = Logger::DEBUG
-  #
-  #   class MyTask < CMDx::Task
-  #     task_settings!(logger: logger)
-  #   end
-  #
-  # @see CMDx::LogFormatters Log formatting options
-  # @see CMDx::ResultLogger Result-specific logging functionality
-  # @see CMDx::Task Task logging integration
+  # This module provides functionality to configure and retrieve logger instances
+  # for task execution, applying task-specific settings such as formatter, level,
+  # and program name when available.
   module Logger
 
     module_function
 
-    # Configures and returns a logger instance for a task.
+    # Configures and returns a logger instance for the given task.
     #
-    # Retrieves the logger from task settings and applies additional configuration
-    # including formatter, log level, and progname if specified in task settings.
-    # Returns nil if no logger is configured.
+    # This method retrieves the logger from task settings and applies any
+    # available configuration options including formatter, level, and program name.
+    # The task itself is set as the logger's program name for identification.
     #
-    # @param task [CMDx::Task] The task instance to configure logging for
-    # @return [::Logger, nil] Configured logger instance or nil if not set
+    # @param task [Task] the task instance to configure logging for
     #
-    # @example Basic logger retrieval
-    #   task = ProcessOrderTask.new
-    #   logger = Logger.call(task)
-    #   logger.info "Task started" if logger
+    # @return [Logger, nil] the configured logger instance or nil if no logger is set
     #
-    # @example Logger with custom formatter
-    #   class MyTask < CMDx::Task
-    #     task_settings!(
-    #       logger: Logger.new(STDOUT),
-    #       log_formatter: CMDx::LogFormatters::Json.new
-    #     )
-    #   end
-    #
-    #   task = MyTask.new
-    #   logger = Logger.call(task)  # Logger with JSON formatter applied
-    #
-    # @example Logger with custom level
-    #   class MyTask < CMDx::Task
-    #     task_settings!(
-    #       logger: Logger.new(STDOUT),
-    #       log_level: Logger::DEBUG
-    #     )
-    #   end
+    # @example Configure logger for a task
+    #   logger = CMDx::Logger.call(task)
+    #   logger.info("Task started")
     #
-    #   task = MyTask.new
-    #   logger = Logger.call(task)  # Logger with DEBUG level applied
-    #
-    # @example No logger configured
-    #   class MyTask < CMDx::Task
-    #     # No logger setting
-    #   end
-    #
-    #   task = MyTask.new
-    #   logger = Logger.call(task)  # => nil
+    # @example Logger with custom formatter
+    #   task.set_cmd_setting(:log_formatter, custom_formatter)
+    #   logger = CMDx::Logger.call(task)
+    #   logger.debug("Debug message")
     def call(task)
-      logger = task.task_setting(:logger)
+      logger = task.cmd_setting(:logger)
 
       unless logger.nil?
-        logger.formatter = task.task_setting(:log_formatter) if task.task_setting?(:log_formatter)
-        logger.level     = task.task_setting(:log_level) if task.task_setting?(:log_level)
+        logger.formatter = task.cmd_setting(:log_formatter) if task.cmd_setting?(:log_formatter)
+        logger.level     = task.cmd_setting(:log_level) if task.cmd_setting?(:log_level)
         logger.progname  = task
       end