Module: LoggingHelpers

Defined in:
lib/story_teller/logging.rb,
lib/story_teller/logging.rb

Overview

The LoggingHelpers module

Constant Summary collapse

FORWARD_SLASH_PATTERN = 
%r{/}
RubyLogLevels = 
{
  all: -Float::INFINITY,
  trace: Logger::TRACE,
  debug: Logger::DEBUG,
  info: Logger::INFO,
  warn: Logger::WARN,
  error: Logger::ERROR,
  fatal: Logger::FATAL,
  unknown: Logger::UNKNOWN,
  off: Logger::UNKNOWN + 1
}.freeze

Class Method Summary collapse

Class Method Details

.get_formatted_logger_name(obj, logger_name = nil) ⇒ Object 



249
250
251
252
253
 
# File 'lib/story_teller/logging.rb', line 249

def get_formatted_logger_name(obj, logger_name = nil)
  return logger_name.to_s if !logger_name.nil? && logger_name.respond_to?(:to_s)
  return obj.name if obj.is_a?(Class) || obj.is_a?(Module)
  obj.class.name
end

.init_java_logger(obj, level = nil, logger_name = nil, source_location = nil) ⇒ Object 



231
232
233
234
235
236
237
 
# File 'lib/story_teller/logging.rb', line 231

def init_java_logger(obj, level = nil, logger_name = nil, source_location = nil)
  logger_name = get_formatted_logger_name(obj, logger_name)
  logger_name = source_location.split(FORWARD_SLASH_PATTERN).last if logger_name.empty?
  log = LogManager.getLogger(logger_name)
  log.level = Level.to_level(level.to_s.upcase) unless level.nil?
  log
end

.init_log4j(log_level = org.apache.logging.log4j.Level::INFO) ⇒ Object

rubocop: disable Metrics/AbcSize rubocop: disable Metrics/MethodLength



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/story_teller/logging.rb', line 78

def init_log4j(log_level = org.apache.logging.log4j.Level::INFO)
  java.lang::System.setProperty('log4j.shutdownHookEnabled', java.lang::Boolean.toString(false))
  config = ConfigurationBuilderFactory.newConfigurationBuilder()

  log_level = Level.to_level(log_level.to_s.upcase) if log_level.is_a? Symbol
  config.setStatusLevel(log_level)
  config.setConfigurationName(LoggingConfiguration.config[:name])

  # create a console appender
  target = ConsoleAppender::Target::SYSTEM_OUT
  pattern = LoggingConfiguration.config[:logging_pattern_template][:java]
  layout = config.newLayout('PatternLayout')
  layout = layout.addAttribute('pattern', pattern)
  appender = config.newAppender('stdout', 'CONSOLE')
  appender = appender.addAttribute('target', target)
  appender = appender.add(layout)
  config.add(appender)

  # create a root logger
  root_logger = config.newRootLogger(log_level)
  root_logger = root_logger.add(config.newAppenderRef('stdout'))

  # create a rolling file appender
  cron = config.newComponent('CronTriggeringPolicy')
  cron = cron.addAttribute('schedule', '0 0 0 * * ?')

  size = config.newComponent('SizeBasedTriggeringPolicy')
  size = size.addAttribute('size', LoggingConfiguration.config[:size])

  policies = config.newComponent('Policies')
  policies = policies.addComponent(cron)
  policies = policies.addComponent(size)

  appender = config.newAppender('rolling_file', 'RollingFile')
  appender = appender.addAttribute(
    'fileName', LoggingConfiguration.config[:log_file_path])
  appender = appender.addAttribute(
    'filePattern', LoggingConfiguration.config[:rolling_log_file_name_template])
  appender = appender.add(layout)
  appender = appender.addComponent(policies)
  config.add(appender)

  root_logger = root_logger.addAttribute('additivity', false)
  root_logger = root_logger.add(config.newAppenderRef('rolling_file'))
  config.add(root_logger)

  logging_configuration = config.build()
  ctx = Configurator.initialize(logging_configuration)
  ctx.updateLoggers()
end

.init_logger(obj, level = :info, logger_name = nil) ⇒ Object 



207
208
209
210
 
# File 'lib/story_teller/logging.rb', line 207

def init_logger(obj, level = :info, logger_name = nil)
  return init_java_logger(obj, level, logger_name, caller[2]) if defined?(Java)
  init_ruby_logger(obj, level, logger_name, caller[2])
end

.init_ruby_logger(obj, level = nil, logger_name = nil, source_location = nil) ⇒ Object 



221
222
223
224
225
226
227
228
 
# File 'lib/story_teller/logging.rb', line 221

def init_ruby_logger(obj, level = nil, logger_name = nil, source_location = nil)
  logger_name = get_formatted_logger_name(obj, logger_name)
  logger_name = source_location.split(FORWARD_SLASH_PATTERN).last if logger_name.empty?
  log = ExtraLogger.new($stdout, progname: logger_name)
  log.level = normalize_ruby_log_level(level) unless level.nil?
  log.formatter = method(:ruby_log_formatter)
  log
end

.normalize_ruby_log_level(level) ⇒ Object 



240
241
242
243
244
245
246
 
# File 'lib/story_teller/logging.rb', line 240

def normalize_ruby_log_level(level)
  return level if level.is_a?(Integer)

  RubyLogLevels.fetch(level.to_sym) do
    raise ArgumentError, "Unknown Ruby log level: #{level.inspect}"
  end
end

.ruby_log_formatter(severity_level, datetime, program_name, message) ⇒ Object 



213
214
215
216
217
218
 
# File 'lib/story_teller/logging.rb', line 213

def ruby_log_formatter(severity_level, datetime, program_name, message)
  format(
    LoggingConfiguration.config[:logging_pattern_template][:ruby],
    timestamp: datetime.strftime(LoggingConfiguration.config[:logging_timestamp_format]),
    progname: program_name, severity: severity_level, msg: message)
end

.symbolize_numeric_log_level(level) ⇒ Object

rubocop: disable Metrics/CyclomaticComplexity OFF: 0 FATAL: 100 ERROR: 200 WARN: 300 INFO: 400 DEBUG: 500 TRACE: 600 ALL: 2147483647 See: logging.apache.org/log4j/2.x/log4j-api/apidocs/org/apache/logging/log4j/Level.html



278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/story_teller/logging.rb', line 278

def symbolize_numeric_log_level(level)
  case level
  when 5..Float::INFINITY then :off
  when 4 then :fatal
  when 3 then :error
  when 2 then :warn
  when 1 then :info
  when 0 then :debug
  when -1 then :trace
  when -Float::INFINITY..-2 then :all
  end
end