def report( log_level, component, code, data )
      return unless self.report?( log_level )

      @pool.communicate(
        Payload.new(
          log_level: log_level,
          component: component,
          code:      code,
          data:      data
        )
      )
    end
def report( log_level, component, code, data )
      return unless self.report?( log_level )

      @pool.communicate(
        Payload.new(
          log_level: log_level,
          component: component,
          code:      code,
          data:      data
        )
      )
    end
Logs a message using the structured logger. Whether or not log data is
 written in a stuctured manner depends upon the writer(s) in use (see
 #add). Structured writers preserve data structures like hashes or arrays
 rather than (say) dumping things out as strings into flat output streams.

 As with flat logging methods #debug, #info, #warn and #error, a
 message is only logged if the logging threshold level (see #level=) is
 set to an equal or lower level.

 +log_level+:: Log level as a symbol - one of, from most trivial to most
               severe, +:debug+, +:info+, +:warn+ or +:error+.

 +component+:: Component; for example, the resource name for a specific
               resource endpoint implementation, 'Middleware' for Hoodoo
               middleware itself, or some other name you think is useful.
               String or Symbol.

 +code+::      Component-defined code. Think of this in a manner similar
               to platform error codes, appearing after the "."; messages
               related to the same thing should share the same code. The
               intent is to produce log data that someone can filter on
               code to get useful information about that specific aspect
               of a service implementation's behaviour.

 +data+::      A Hash containing the level-, component- and code-dependent
               payload data to be logged.