fluentd 0.14.11-x64-mingw32 → 0.14.12-x64-mingw32

data/lib/fluent/config/configure_proxy.rb

@@ -126,7 +126,7 @@ module Fluent
         merged.configured_in_section = self.configured_in_section || other.configured_in_section
 
         merged.argument = other.argument || self.argument
-        merged.params = other.params.merge(self.params)
+        merged.params = self.params.merge(other.params)
         merged.defaults = self.defaults.merge(other.defaults)
         merged.sections = {}
         (self.sections.keys + other.sections.keys).uniq.each do |section_key|
@@ -226,19 +226,41 @@ module Fluent
         end
       end
 
+      def config_parameter_option_validate!(name, type, **kwargs, &block)
+        if type.nil? && !block
+          type = :string
+        end
+        kwargs.each_key do |key|
+          case key
+          when :default, :alias, :secret, :skip_accessor, :deprecated, :obsoleted, :desc
+            # valid for all types
+          when :list
+            raise ArgumentError, ":list is valid only for :enum type, but #{type}: #{name}" if type != :enum
+          when :value_type
+            raise ArgumentError, ":value_type is valid only for :hash and :array, but #{type}: #{name}" if type != :hash && type != :array
+          when :symbolize_keys
+            raise ArgumentError, ":symbolize_keys is valid only for :hash, but #{type}: #{name}" if type != :hash
+          else
+            raise ArgumentError, "unknown option '#{key}' for configuration parameter: #{name}"
+          end
+        end
+      end
+
       def parameter_configuration(name, type = nil, **kwargs, &block)
-        name = name.to_sym
+        config_parameter_option_validate!(name, type, **kwargs, &block)
 
-        opts = {}
-        opts[:type] = type
-        opts.merge!(kwargs)
+        name = name.to_sym
 
         if block && type
           raise ArgumentError, "#{name}: both of block and type cannot be specified"
+        elsif !block && !type
+          type = :string
         end
+        opts = {}
+        opts[:type] = type
+        opts.merge!(kwargs)
 
         begin
-          type = :string if type.nil?
           block ||= @type_lookup.call(type)
         rescue ConfigError
           # override error message
@@ -252,10 +274,11 @@ module Fluent
         option_value_type!(name, opts, :deprecated, String)
         option_value_type!(name, opts, :obsoleted, String)
         if type == :enum
-          if !opts.has_key?(:list) || !opts[:list].all?{|v| v.is_a?(Symbol) }
+          if !opts.has_key?(:list) || !opts[:list].is_a?(Array) || opts[:list].empty? || !opts[:list].all?{|v| v.is_a?(Symbol) }
             raise ArgumentError, "#{name}: enum parameter requires :list of Symbols"
           end
         end
+        option_value_type!(name, opts, :symbolize_keys, type: :boolean)
         option_value_type!(name, opts, :value_type, Symbol) # hash, array
         option_value_type!(name, opts, :skip_accessor, type: :boolean)
 

data/lib/fluent/config/section.rb

@@ -75,6 +75,10 @@ module Fluent
         @params[key.to_sym]
       end
 
+      def []=(key, value)
+        @params[key.to_sym] = value
+      end
+
       def respond_to?(symbol, include_all=false)
         case symbol
         when :inspect, :nil?, :to_h, :+, :instance_of?, :kind_of?, :[], :respond_to?, :respond_to_missing?

data/lib/fluent/config/types.rb

@@ -64,7 +64,7 @@ module Fluent
       end
     end
 
-    STRING_TYPE = Proc.new { |val, opts| val }
+    STRING_TYPE = Proc.new { |val, opts| val.to_s.encode(Encoding::UTF_8) }
     ENUM_TYPE = Proc.new { |val, opts|
       s = val.to_sym
       list = opts[:list]
@@ -85,7 +85,7 @@ module Fluent
         value
       else
         case type
-        when :string  then value.to_s
+        when :string  then value.to_s.encode(Encoding::UTF_8)
         when :integer then value.to_i
         when :float   then value.to_f
         when :size then Config.size_value(value)

data/lib/fluent/configurable.rb

@@ -48,12 +48,8 @@ module Fluent
       end
     end
 
-    def configure(conf)
-      @config = conf
-
-      logger = self.respond_to?(:log) ? log : (defined?($log) ? $log : nil)
+    def configure_proxy_generate
       proxy = self.class.merged_configure_proxy
-      conf.corresponding_proxies << proxy
 
       if self.respond_to?(:owner) && self.owner
         owner_proxy = owner.class.merged_configure_proxy
@@ -63,6 +59,36 @@ module Fluent
         proxy.overwrite_defaults(owner_proxy) if owner_proxy
       end
 
+      proxy
+    end
+
+    def configured_section_create(name, conf = nil)
+      conf ||= Fluent::Config::Element.new(name.to_s, '', {}, [])
+      root_proxy = configure_proxy_generate
+      proxy = if name.nil? # root
+                root_proxy
+              else
+                root_proxy.sections[name]
+              end
+      # take care to raise Fluent::ConfigError if conf mismatched to proxy
+      Fluent::Config::SectionGenerator.generate(proxy, conf, nil, nil)
+    end
+
+    def configure(conf)
+      @config = conf
+
+      logger = if self.respond_to?(:log)
+                 self.log
+               elsif self.respond_to?(:owner) && self.owner.respond_to?(:log)
+                 self.owner.log
+               elsif defined?($log)
+                 $log
+               else
+                 nil
+               end
+      proxy = configure_proxy_generate
+      conf.corresponding_proxies << proxy
+
       # In the nested section, can't get plugin class through proxies so get plugin class here
       plugin_class = Fluent::Plugin.lookup_type_from_class(proxy.name.to_s)
       root = Fluent::Config::SectionGenerator.generate(proxy, conf, logger, plugin_class)

data/lib/fluent/engine.rb

@@ -29,13 +29,15 @@ module Fluent
 
     def initialize
       @root_agent = nil
-      @event_router = nil
       @default_loop = nil
       @engine_stopped = false
 
+      @log_event_router = nil
       @log_emit_thread = nil
       @log_event_loop_stop = false
+      @log_event_loop_graceful_stop = false
       @log_event_queue = []
+      @log_event_verbose = false
 
       @suppress_config_dump = false
 
@@ -58,6 +60,8 @@ module Fluent
       @suppress_config_dump = system_config.suppress_config_dump unless system_config.suppress_config_dump.nil?
       @without_source = system_config.without_source unless system_config.without_source.nil?
 
+      @log_event_verbose = system_config.log_event_verbose unless system_config.log_event_verbose.nil?
+
       @root_agent = RootAgent.new(log: log, system_config: @system_config)
 
       MessagePackFactory.init
@@ -93,12 +97,12 @@ module Fluent
                     else
                       "section <#{e.name}> is not used in <#{parent_name}>"
                     end
-          $log.warn message
+          $log.warn :worker0, message
           next
         end
         unless e.name == 'system'
           unless @without_source && e.name == 'source'
-            $log.warn "parameter '#{key}' in #{e.to_s.strip} is not used."
+            $log.warn :worker0, "parameter '#{key}' in #{e.to_s.strip} is not used."
           end
         end
       }
@@ -107,14 +111,43 @@ module Fluent
     def configure(conf)
       # plugins / configuration dumps
       Gem::Specification.find_all.select{|x| x.name =~ /^fluent(d|-(plugin|mixin)-.*)$/}.each do |spec|
-        $log.info "gem '#{spec.name}' version '#{spec.version}'"
+        $log.info :worker0, "gem '#{spec.name}' version '#{spec.version}'"
       end
 
       @root_agent.configure(conf)
-      @event_router = @root_agent.event_router
+
+      begin
+        log_event_agent = @root_agent.find_label(Fluent::Log::LOG_EVENT_LABEL)
+        log_event_router = log_event_agent.event_router
+
+        # suppress mismatched tags only for <label @FLUENT_LOG> label.
+        # it's not suppressed in default event router for non-log-event events
+        log_event_router.suppress_missing_match!
+
+        @log_event_router = log_event_router
+
+        unmatched_tags = Fluent::Log.event_tags.select{|t| !@log_event_router.match?(t) }
+        unless unmatched_tags.empty?
+          $log.warn :worker0, "match for some tags of log events are not defined (to be ignored)", tags: unmatched_tags
+        end
+      rescue ArgumentError # ArgumentError "#{label_name} label not found"
+        # use default event router if <label @FLUENT_LOG> is missing in configuration
+        log_event_router = @root_agent.event_router
+
+        if Fluent::Log.event_tags.any?{|t| log_event_router.match?(t) }
+          @log_event_router = log_event_router
+
+          unmatched_tags = Fluent::Log.event_tags.select{|t| !@log_event_router.match?(t) }
+          unless unmatched_tags.empty?
+            $log.warn :worker0, "match for some tags of log events are not defined (to be ignored)", tags: unmatched_tags
+          end
+        end
+      end
+
+      $log.enable_event(true) if @log_event_router
 
       unless @suppress_config_dump
-        $log.info "using configuration file: #{conf.to_s.rstrip}"
+        $log.info :worker0, "using configuration file: #{conf.to_s.rstrip}"
       end
     end
 
@@ -148,6 +181,7 @@ module Fluent
 
       while sleep(LOG_EMIT_INTERVAL)
         break if @log_event_loop_stop
+        break if @log_event_loop_graceful_stop && @log_event_queue.empty?
         next if @log_event_queue.empty?
 
         # NOTE: thead-safe of slice! depends on GVL
@@ -156,8 +190,9 @@ module Fluent
 
         events.each {|tag,time,record|
           begin
-            @event_router.emit(tag, time, record)
+            @log_event_router.emit(tag, time, record)
           rescue => e
+            # This $log.error doesn't emit log events, because of `$log.disable_events(Thread.current)` above
             $log.error "failed to emit fluentd's log event", tag: tag, event: record, error: e
           end
         }
@@ -165,18 +200,23 @@ module Fluent
     end
 
     def run
+      # if ENV doesn't have SERVERENGINE_WORKER_ID, it is a worker under --no-supervisor or in tests
+      # so it's (almost) a single worker, worker_id=0
+      worker_id = (ENV['SERVERENGINE_WORKER_ID'] || 0).to_i
+
       begin
-        worker_id = ENV['SERVERENGINE_WORKER_ID']
         $log.info "starting fluentd worker", pid: Process.pid, ppid: Process.ppid, worker: worker_id
         start
 
-        if @event_router.match?($log.tag)
-          $log.enable_event
+        if @log_event_router
+          $log.enable_event(true)
           @log_emit_thread = Thread.new(&method(:log_event_loop))
+          @log_emit_thread.abort_on_exception = true
         end
 
-        $log.info "fluentd worker is now running" # TODO: worker number
+        $log.info "fluentd worker is now running", worker: worker_id
         sleep MAINLOOP_SLEEP_INTERVAL until @engine_stopped
+        $log.info "fluentd worker is now stopping", worker: worker_id
 
       rescue Exception => e
         $log.error "unexpected error", error: e
@@ -184,7 +224,16 @@ module Fluent
         raise
       end
 
-      $log.info "shutting down fluentd worker" # TODO: worker number
+      unless @log_event_verbose
+        $log.enable_event(false)
+        if @log_emit_thread
+          # to make sure to emit all log events into router, before shutting down
+          @log_event_loop_graceful_stop = true
+          @log_emit_thread.join
+          @log_emit_thread = nil
+        end
+      end
+      $log.info "shutting down fluentd worker", worker: worker_id
       shutdown
       if @log_emit_thread
         @log_event_loop_stop = true

data/lib/fluent/event_router.rb

@@ -71,6 +71,12 @@ module Fluent
       attr_reader :pattern_str
     end
 
+    def suppress_missing_match!
+      if @default_collector.respond_to?(:suppress_missing_match!)
+        @default_collector.suppress_missing_match!
+      end
+    end
+
     # called by Agent to add new match pattern and collector
     def add_rule(pattern, collector)
       @match_rules << Rule.new(pattern, collector)

data/lib/fluent/load.rb

@@ -25,7 +25,6 @@ require 'fluent/config'
 require 'fluent/engine'
 require 'fluent/rpc'
 require 'fluent/mixin'
-require 'fluent/process'
 require 'fluent/plugin'
 require 'fluent/parser'
 require 'fluent/formatter'

data/lib/fluent/log.rb

@@ -42,6 +42,14 @@ module Fluent
 
     LEVEL_TEXT = %w(trace debug info warn error fatal)
 
+    LOG_EVENT_TAG_PREFIX = 'fluent'
+    LOG_EVENT_LABEL = '@FLUENT_LOG'
+    LOG_TYPE_SUPERVISOR = :supervisor # only in supervisor, or a worker with --no-supervisor
+    LOG_TYPE_WORKER0 = :worker0 # only in a worker with worker_id=0 (without showing worker id)
+    LOG_TYPE_DEFAULT = :default # show logs in all supervisor/workers, with worker id in workers (default)
+
+    LOG_TYPES = [LOG_TYPE_SUPERVISOR, LOG_TYPE_WORKER0, LOG_TYPE_DEFAULT].freeze
+
     def self.str_to_level(log_level_str)
       case log_level_str.downcase
       when "trace" then LEVEL_TRACE
@@ -54,6 +62,10 @@ module Fluent
       end
     end
 
+    def self.event_tags
+      LEVEL_TEXT.map{|t| "#{LOG_EVENT_TAG_PREFIX}.#{t}" }
+    end
+
     def initialize(logger, opts={})
       # overwrites logger.level= so that config reloading resets level of Fluentd::Log
       orig_logger_level_setter = logger.class.public_instance_method(:level=).bind(logger)
@@ -83,8 +95,7 @@ module Fluent
       @out = logger.instance_variable_get(:@logdev)
       @level = logger.level + 1
       @debug_mode = false
-      @self_event = false
-      @tag = 'fluent'
+      @log_event_enabled = false
       @time_format = '%Y-%m-%d %H:%M:%S %z '
       @depth_offset = 1
       enable_color out.tty?
@@ -97,22 +108,43 @@ module Fluent
       @optional_attrs = nil
 
       @suppress_repeated_stacktrace = opts[:suppress_repeated_stacktrace]
+
+      @process_type = opts[:process_type] # :supervisor, :worker0, :workers Or :standalone
+      @process_type ||= :standalone # to keep behavior of existing code
+      case @process_type
+      when :supervisor
+        @show_supervisor_log = true
+        @show_worker0_log = false
+      when :worker0
+        @show_supervisor_log = false
+        @show_worker0_log = true
+      when :workers
+        @show_supervisor_log = false
+        @show_worker0_log = false
+      when :standalone
+        @show_supervisor_log = true
+        @show_worker0_log = true
+      else
+        raise "BUG: unknown process type for logger:#{@process_type}"
+      end
+      @worker_id = opts[:worker_id]
+      @worker_id_part = "##{@worker_id} " # used only for :default log type in workers
     end
 
     def dup
       dl_opts = {}
       dl_opts[:log_level] = @level - 1
       logger = ServerEngine::DaemonLogger.new(@out, dl_opts)
-      clone = self.class.new(logger, suppress_repeated_stacktrace: @suppress_repeated_stacktrace)
-      clone.tag = @tag
+      clone = self.class.new(logger, suppress_repeated_stacktrace: @suppress_repeated_stacktrace, process_type: @process_type, worker_id: @worker_id)
       clone.time_format = @time_format
+      clone.log_event_enabled = @log_event_enabled
       # optional headers/attrs are not copied, because new PluginLogger should have another one of it
       clone
     end
 
+    attr_accessor :log_event_enabled
     attr_accessor :out
     attr_accessor :level
-    attr_accessor :tag
     attr_accessor :time_format
     attr_accessor :optional_header, :optional_attrs
 
@@ -134,10 +166,17 @@ module Fluent
     end
 
     def enable_event(b=true)
-      @self_event = b
+      @log_event_enabled = b
       self
     end
 
+    # If you want to suppress event emitting in specific thread, please use this method.
+    # Events in passed thread are never emitted.
+    def disable_events(thread)
+      # this method is not symmetric with #enable_event.
+      @threads_exclude_events.push(thread) unless @threads_exclude_events.include?(thread)
+    end
+
     def enable_color?
       !@color_reset.empty?
     end
@@ -163,10 +202,26 @@ module Fluent
       self
     end
 
-    # If you want to suppress event emitting in specific thread, please use this method.
-    # Events in passed thread are never emitted.
-    def disable_events(thread)
-      @threads_exclude_events.push(thread) unless @threads_exclude_events.include?(thread)
+    def log_type(args)
+      if LOG_TYPES.include?(args.first)
+        args.shift
+      else
+        LOG_TYPE_DEFAULT
+      end
+    end
+
+    # TODO: skip :worker0 logs when Fluentd gracefully restarted
+    def skipped_type?(type)
+      case type
+      when LOG_TYPE_DEFAULT
+        false
+      when LOG_TYPE_WORKER0
+        !@show_worker0_log
+      when LOG_TYPE_SUPERVISOR
+        !@show_supervisor_log
+      else
+        raise "BUG: unknown log type:#{type}"
+      end
     end
 
     def on_trace(&block)
@@ -176,16 +231,18 @@ module Fluent
 
     def trace(*args, &block)
       return if @level > LEVEL_TRACE
+      type = log_type(args)
+      return if skipped_type?(type)
       args << block.call if block
       time, msg = event(:trace, args)
-      puts [@color_trace, caller_line(time, @depth_offset, LEVEL_TRACE), msg, @color_reset].join
+      puts [@color_trace, caller_line(type, time, @depth_offset, LEVEL_TRACE), msg, @color_reset].join
     rescue
       # logger should not raise an exception. This rescue prevents unexpected behaviour.
     end
     alias TRACE trace
 
-    def trace_backtrace(backtrace=$!.backtrace)
-      dump_stacktrace(backtrace, LEVEL_TRACE)
+    def trace_backtrace(backtrace=$!.backtrace, type: :default)
+      dump_stacktrace(type, backtrace, LEVEL_TRACE)
     end
 
     def on_debug(&block)
@@ -195,15 +252,17 @@ module Fluent
 
     def debug(*args, &block)
       return if @level > LEVEL_DEBUG
+      type = log_type(args)
+      return if skipped_type?(type)
       args << block.call if block
       time, msg = event(:debug, args)
-      puts [@color_debug, caller_line(time, @depth_offset, LEVEL_DEBUG), msg, @color_reset].join
+      puts [@color_debug, caller_line(type, time, @depth_offset, LEVEL_DEBUG), msg, @color_reset].join
     rescue
     end
     alias DEBUG debug
 
-    def debug_backtrace(backtrace=$!.backtrace)
-      dump_stacktrace(backtrace, LEVEL_DEBUG)
+    def debug_backtrace(backtrace=$!.backtrace, type: :default)
+      dump_stacktrace(type, backtrace, LEVEL_DEBUG)
     end
 
     def on_info(&block)
@@ -213,15 +272,17 @@ module Fluent
 
     def info(*args, &block)
       return if @level > LEVEL_INFO
+      type = log_type(args)
+      return if skipped_type?(type)
       args << block.call if block
       time, msg = event(:info, args)
-      puts [@color_info, caller_line(time, @depth_offset, LEVEL_INFO), msg, @color_reset].join
+      puts [@color_info, caller_line(type, time, @depth_offset, LEVEL_INFO), msg, @color_reset].join
     rescue
     end
     alias INFO info
 
-    def info_backtrace(backtrace=$!.backtrace)
-      dump_stacktrace(backtrace, LEVEL_INFO)
+    def info_backtrace(backtrace=$!.backtrace, type: :default)
+      dump_stacktrace(type, backtrace, LEVEL_INFO)
     end
 
     def on_warn(&block)
@@ -231,15 +292,17 @@ module Fluent
 
     def warn(*args, &block)
       return if @level > LEVEL_WARN
+      type = log_type(args)
+      return if skipped_type?(type)
       args << block.call if block
       time, msg = event(:warn, args)
-      puts [@color_warn, caller_line(time, @depth_offset, LEVEL_WARN), msg, @color_reset].join
+      puts [@color_warn, caller_line(type, time, @depth_offset, LEVEL_WARN), msg, @color_reset].join
     rescue
     end
     alias WARN warn
 
-    def warn_backtrace(backtrace=$!.backtrace)
-      dump_stacktrace(backtrace, LEVEL_WARN)
+    def warn_backtrace(backtrace=$!.backtrace, type: :default)
+      dump_stacktrace(type, backtrace, LEVEL_WARN)
     end
 
     def on_error(&block)
@@ -249,15 +312,17 @@ module Fluent
 
     def error(*args, &block)
       return if @level > LEVEL_ERROR
+      type = log_type(args)
+      return if skipped_type?(type)
       args << block.call if block
       time, msg = event(:error, args)
-      puts [@color_error, caller_line(time, @depth_offset, LEVEL_ERROR), msg, @color_reset].join
+      puts [@color_error, caller_line(type, time, @depth_offset, LEVEL_ERROR), msg, @color_reset].join
     rescue
     end
     alias ERROR error
 
-    def error_backtrace(backtrace=$!.backtrace)
-      dump_stacktrace(backtrace, LEVEL_ERROR)
+    def error_backtrace(backtrace=$!.backtrace, type: :default)
+      dump_stacktrace(type, backtrace, LEVEL_ERROR)
     end
 
     def on_fatal(&block)
@@ -267,15 +332,17 @@ module Fluent
 
     def fatal(*args, &block)
       return if @level > LEVEL_FATAL
+      type = log_type(args)
+      return if skipped_type?(type)
       args << block.call if block
       time, msg = event(:fatal, args)
-      puts [@color_fatal, caller_line(time, @depth_offset, LEVEL_FATAL), msg, @color_reset].join
+      puts [@color_fatal, caller_line(type, time, @depth_offset, LEVEL_FATAL), msg, @color_reset].join
     rescue
     end
     alias FATAL fatal
 
-    def fatal_backtrace(backtrace=$!.backtrace)
-      dump_stacktrace(backtrace, LEVEL_FATAL)
+    def fatal_backtrace(backtrace=$!.backtrace, type: :default)
+      dump_stacktrace(type, backtrace, LEVEL_FATAL)
     end
 
     def puts(msg)
@@ -299,11 +366,11 @@ module Fluent
       @out.reset if @out.respond_to?(:reset)
     end
 
-    def dump_stacktrace(backtrace, level)
+    def dump_stacktrace(type, backtrace, level)
       return if @level > level
 
       time = Time.now
-      line = caller_line(time, 5, level)
+      line = caller_line(type, time, 5, level)
       if @suppress_repeated_stacktrace && (Thread.current[:last_repeated_stacktrace] == backtrace)
         puts ["  ", line, 'suppressed same stacktrace'].join
       else
@@ -338,20 +405,25 @@ module Fluent
         end
       }
 
-      unless @threads_exclude_events.include?(Thread.current)
+      if @log_event_enabled && !@threads_exclude_events.include?(Thread.current)
         record = map.dup
         record.keys.each {|key|
           record[key] = record[key].inspect unless record[key].respond_to?(:to_msgpack)
         }
         record['message'] = message.dup
-        @engine.push_log_event("#{@tag}.#{level}", time.to_i, record)
+        @engine.push_log_event("#{LOG_EVENT_TAG_PREFIX}.#{level}", Fluent::EventTime.from_time(time), record)
       end
 
       return time, message
     end
 
-    def caller_line(time, depth, level)
-      log_msg = "#{time.strftime(@time_format)}[#{LEVEL_TEXT[level]}]: "
+    def caller_line(type, time, depth, level)
+      worker_id_part = if type == :default && (@process_type == :worker0 || @process_type == :workers)
+                         @worker_id_part
+                       else
+                         "".freeze
+                       end
+      log_msg = "#{time.strftime(@time_format)}[#{LEVEL_TEXT[level]}]: #{worker_id_part}"
       if @debug_mode
         line = caller(depth+1)[0]
         if match = /^(.+?):(\d+)(?::in `(.*)')?/.match(line)
@@ -370,7 +442,7 @@ module Fluent
   # This class enables log_level option in each plugin.
   #
   # PluginLogger has same functionality as Log but some methods are forwarded to internal logger
-  # for keeping logging action consistency in the process, e.g. color, tag, event, etc.
+  # for keeping logging action consistency in the process, e.g. color, event, etc.
   class PluginLogger < Log
     def initialize(logger)
       @logger = logger
@@ -396,7 +468,7 @@ module Fluent
 
     extend Forwardable
     def_delegators '@logger', :enable_color?, :enable_debug, :enable_event,
-      :disable_events, :tag, :tag=, :time_format, :time_format=,
+      :disable_events, :log_event_enabled, :log_event_enamed=, :time_format, :time_format=,
       :event, :caller_line, :puts, :write, :flush, :reset, :out, :out=,
       :optional_header, :optional_header=, :optional_attrs, :optional_attrs=
   end
@@ -421,13 +493,17 @@ module Fluent
     def configure(conf)
       super
 
-      if level = conf['@log_level']
-        unless @log.is_a?(PluginLogger)
-          @log = PluginLogger.new($log.dup)
-        end
-        @log.level = level
-        @log.optional_header = "[#{self.class.name}#{plugin_id_configured? ? "(" + @id + ")" : ""}] "
+      if plugin_id_configured? || conf['@log_level']
+        @log = PluginLogger.new($log.dup) unless @log.is_a?(PluginLogger)
         @log.optional_attrs = {}
+
+        if level = conf['@log_level']
+          @log.level = level
+        end
+
+        if plugin_id_configured?
+          @log.optional_header = "[#{@id}] "
+        end
       end
     end