Module: Logged

Extended by:
LevelConversion, Subscriptions
Defined in:
lib/logged.rb,
lib/logged/logger.rb,
lib/logged/railtie.rb,
lib/logged/version.rb,
lib/logged/rack/logger.rb,
lib/logged/configuration.rb,
lib/logged/formatter/raw.rb,
lib/logged/subscriptions.rb,
lib/logged/formatter/base.rb,
lib/logged/formatter/json.rb,
lib/logged/tagged_logging.rb,
lib/logged/level_conversion.rb,
lib/logged/formatter/logstash.rb,
lib/logged/formatter/key_value.rb,
lib/logged/log_subscriber/base.rb,
lib/logged/formatter/single_key.rb,
lib/logged/log_subscriber/action_view.rb,
lib/logged/log_subscriber/action_mailer.rb,
lib/logged/log_subscriber/active_record.rb,
lib/logged/log_subscriber/action_controller.rb

Overview

logged

Defined Under Namespace

Modules: Formatter, LevelConversion, LogSubscriber, Rack, Subscriptions, TaggedLogging Classes: Configuration, Logger, Railtie

Constant Summary collapse

CONFIG_KEYS =

special keys which not represent a component

Configuration::DEFAULT_VALUES.keys + [:loggers, :disable_rails_logging]
VERSION =

Version

'0.1.0'

Class Method Summary collapse

Methods included from LevelConversion

level_to_const, level_to_sym

Methods included from Subscriptions

rails_subscriber, register, remove_rails_subscriber, require_rails_subscribers, unsubscribe

Class Method Details

.components ⇒ Object

configured components



144
145
146
 
# File 'lib/logged.rb', line 144

def components
  config.keys - CONFIG_KEYS
end

.custom_data(conf, event, data) ⇒ Object

run data callbacks



136
137
138
139
140
141
 
# File 'lib/logged.rb', line 136

def custom_data(conf, event, data)
  return data unless conf.enabled
  return data unless conf.custom_data.respond_to?(:call)

  conf.custom_data.call(event, data)
end

.default_formatter ⇒ Object

default log formatter



40
41
42
 
# File 'lib/logged.rb', line 40

def default_formatter
  config.formatter || (@default_formatter ||= Logged::Formatter::KeyValue.new)
end

.default_level ⇒ Object

default log level



35
36
37
 
# File 'lib/logged.rb', line 35

def default_level
  config.level || :info
end

.enable_component(component) ⇒ Object

configure and enable component



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/logged.rb', line 106

def enable_component(component)
  loggers = loggers_for(component)

  return unless loggers.any?

  loggers.each do |logger, options|
    level = options[:level] || config[component].level || default_level

    logger.level = level_to_const(level) if logger.respond_to?(:'level=')
  end

  # only attach subscribers with loggers
  @subscribers[component].each do |subscriber|
    subscriber.attach_to(component)
  end
end

.ignore?(conf, event) ⇒ Boolean

check if event should be ignored

Returns:

  • (Boolean) 


124
125
126
127
128
129
130
131
132
133
 
# File 'lib/logged.rb', line 124

def ignore?(conf, event)
  return false unless event
  return false unless conf.enabled

  return true if !event.is_a?(String) && conf.ignore.is_a?(Array) && conf.ignore.include?(event.name)

  return conf.custom_ignore.call(event) if conf.custom_ignore.respond_to?(:call)

  false
end

.load_logger(name, conf) ⇒ Object

load logger from configuration



90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/logged.rb', line 90

def load_logger(name, conf)
  return [nil, nil] unless conf.enabled

  options = conf.dup
  options[:name] = name

  logger = options.delete(:logger)

  logger = Rails.logger if logger == :rails

  return [nil, nil] unless logger

  [logger, options]
end

.logger_by_component(component) ⇒ Object Also known as: []

logger wrapper for component



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/logged.rb', line 45

def logger_by_component(component)
  return nil unless config.enabled

  key = "component_#{component}"

  return @component_loggers[key] if @component_loggers.key?(key)

  loggers = loggers_for(component)

  if loggers.blank?
    @component_loggers[key] = nil

    return nil
  end

  formatter = config[component].formatter || default_formatter

  @component_loggers[key] = Logger.new(loggers, component, formatter)
end

.loggers_for(component) ⇒ Object

loggers for component



67
68
69
70
 
# File 'lib/logged.rb', line 67

def loggers_for(component)
  loggers_from_config(config)
    .merge(loggers_from_config(config[component]))
end

.loggers_from_config(conf) ⇒ Object

loggers from config level



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/logged.rb', line 73

def loggers_from_config(conf)
  loggers = {}

  return loggers unless conf.enabled

  conf.loggers.each do |name, c|
    logger, options = load_logger(name, c)

    next unless logger && options

    loggers[logger] = options
  end

  loggers
end

.request_env ⇒ Object

rack request environment



149
150
151
 
# File 'lib/logged.rb', line 149

def request_env
  Thread.current[:logged_request_env]
end

.setup(app) ⇒ Object

setup logged



25
26
27
28
29
30
31
32
 
# File 'lib/logged.rb', line 25

def setup(app)
  self.app    = app
  self.config = app.config.logged

  app.config.middleware.insert_after ::Rails::Rack::Logger, Logged::Rack::Logger

  setup_components
end