logjam 1.0.0 → 1.1.0

Sign up to get free protection for your applications and to get access to all the features.
data/README CHANGED
@@ -1,8 +1,8 @@
1
- LogJam
2
- ======
3
- LogJam is a library that attempts to allow for the aggregation the distributing
4
- logger facilities across a range of classes. Goals in creating this library
5
- were...
1
+ # LogJam
2
+
3
+ LogJam is a library that attempts to allow for the aggregation and the
4
+ distribution of logging facilities across a range of classes. Goals in
5
+ creating this library were...
6
6
 
7
7
  * Easy of use. Fall back on defaults as much as possible and allow the
8
8
  functionality to be integrated and used with the least amount of work.
@@ -20,11 +20,11 @@ were...
20
20
  wanted to minimize the burden this placed on library users at the same
21
21
  time.
22
22
 
23
- Configuration & Setup
24
- ---------------------
25
- The LogJam library is configured through a call to the configure() method on the
26
- LogJam module. This method accepts a single parameter that may be either a
27
- String, a Hash, an IO object or nil.
23
+ ## Configuration & Setup
24
+
25
+ To explicitly configure the settings LogJam you make a call to the
26
+ LogJam#configure() method. This method takes a single parameter which should be
27
+ either a String, a Hash, an IO object or nil.
28
28
 
29
29
  If you pass a String in this is expected to contain the path and name of a file
30
30
  that contains the logging configuration. Logging configuration files can be
@@ -32,7 +32,7 @@ provided in either YAML or JSON format. If you pass an IO object this is
32
32
  expected to be the source of the configuration and, again, this configuration
33
33
  should be in either YAML or JSON format. In either case, where a String or IO
34
34
  is specified, the data read must be translatable into a Hash, which brings us
35
- to the other type that the configure() method accepts as a parameter.
35
+ to the other type that the LogJam#configure() method accepts as a parameter.
36
36
 
37
37
  A Hash passed to the configure() method is expected to contain a set of values
38
38
  that can be converted into a logging set up. Passing an empty Hash will result
@@ -42,37 +42,37 @@ stream being created and used by all classes that have LogJam functionality.
42
42
  The Hash passed to the configure() method can contain two keys that the library
43
43
  will recognise and use. The first of these is 'loggers', in either Symbol or
44
44
  String form. The value under the loggers key is expected to be an Array
45
- containing zero or more logger definitions. A logger definition is a Hash in
46
- which the following keys are recognised (either as Strings or Symbols)...
47
-
48
- Key Description
49
- ----------------------- --------------------------------------------------
50
- default A boolean indicating whether this logger is the
51
- default (i.e. the one to be used when no other
52
- fits the bill). Only one logger should be declared
53
- as a default.
54
- datetime_format The date/time format to be used by the logger. See
55
- the documentation for the standard Ruby Logger
56
- class for more details.
57
- file The path and name of the file that logging details
58
- will be written to. Two special values are
59
- recognised in this value. STDOUT and STDERR are
60
- translated to mean the standard output or error
61
- streams respectively.
62
- level The logging level to set on the logger. If not
63
- explicitly specified this defaults to DEBUG.
64
- max_size When rotation is set to an integer value this value
65
- can be set to indicate the maximum permitted file
66
- size for a log file.
67
- name The name to associate with the logger. This allows
68
- loggers to be tied to classes or for the creation
69
- of aliases that tie multiple names to a single
70
- logger. Note that you should always use Strings
71
- (and not Symbols) when specifying aliases.
72
- rotation The frequency with which the log file is rotated.
73
- This may be an integer to indicate how many old log
74
- files are retained or may be a String such as
75
- "daily", "weekly" or "monthly".
45
+ containing zero or more logger definitions. An individual logger definition is
46
+ itself a Hash in which the following keys are recognised (either as Strings or
47
+ Symbols) - default, datetime_format, file, level, max_size, name and rotation.
48
+ The meanings applied to these keys are as follows...
49
+
50
+ * default: A boolean indicating whether this logger is the default (i.e. the
51
+ one to be used when no other explicitly fits the bill). Only one logger
52
+ should be declared as a default.
53
+
54
+ * datetime_format: The date/time format to be used by the logger. See the
55
+ documentation for the standard Ruby Logger class for more details.
56
+
57
+ * file: The path and name of the file that logging details will be written to.
58
+ Two special values are recognised in this value. STDOUT and STDERR are
59
+ translated to mean the standard output or error streams respectively.
60
+
61
+ * level: The logging level to set on the logger. Must be one of DEBUG, INFO,
62
+ WARN, ERROR, FATAL or UNKNOWN. If not explicitly specified this defaults
63
+ to DEBUG.
64
+
65
+ * max_size: When rotation is set to an integer value this value can be set to
66
+ indicate the maximum permitted file size for a log file.
67
+
68
+ * name: The name to associate with the logger. This allows loggers to be tied
69
+ to classes or for the creation of aliases that tie multiple names to a single
70
+ logger. Note that you should always use Strings (and not Symbols) when
71
+ specifying aliases.
72
+
73
+ * rotation: The frequency with which the log file is rotated. This may be an
74
+ integer to indicate how many old log files are retained or may be a String
75
+ such as "daily", "weekly" or "monthly".
76
76
 
77
77
  A note on logger names. Logger names (including alias names) aren't hierarchical
78
78
  and should be unique.
@@ -84,19 +84,24 @@ alias names and the mapped values are expected to be the name of a logger
84
84
  declared in the logger section. An entry in the aliases Hash creates an alias
85
85
  for an existing logger under a different name.
86
86
 
87
- If you pass nil to the configure method it behaves in a slightly different
88
- fashion. In this case the method searches for a configuration file that it can
89
- use given a default set of files names (basically logging.yaml, logging.yml and
90
- logging.json in the current working directory and in a subdirectory of the
87
+ The final parameter option when calling LogJam#configure() is to pass a nil to
88
+ the method. If you pass nil to the configure method it behaves in a slightly
89
+ different fashion. In this case the method searches for a configuration file
90
+ that it can use given a default set of files names (logging.yaml, logging.yml
91
+ and logging.json in the current working directory and in a subdirectory of the
91
92
  current working directory called config). The first of these files that it finds
92
93
  it attempts to use as configuration for the logging set up. If it doesn't find
93
94
  a configuration file then this type of call becomes equivalent to passing an
94
- empty Hash to the configure() method.
95
+ empty Hash to the configure() method. As of version 1.1.0 the library includes
96
+ an implicit call to LogJam#configure(nil) removing the need to do this
97
+ explicitly in your own code.
95
98
 
96
- See the end of this document for some example configurations.
99
+ Note that you can call LogJam#configure multiple times, with each successive
100
+ call overwriting and replacing the details of previous calls. See the end of
101
+ this document for some example configurations.
102
+
103
+ ## Logging With The Library
97
104
 
98
- Logging With The Library
99
- ------------------------
100
105
  The stated goals of the LogJam library are to avoid the need to pass Logger
101
106
  instances around while still allowing potentially complex configuration with a
102
107
  minimum of code. The first step in this process has been covered in the
@@ -105,42 +110,60 @@ from a single Hash or file. This section will provide details on how to deploy
105
110
  loggers to various classes.
106
111
 
107
112
  The LogJam library works by providing an extension to any class that uses it
108
- that provides access to the logger to be used by the class. To make use of this
109
- functionality a class must call the apply() method of the LogJam module. A
110
- typical call to this method might look like...
111
-
113
+ that provides access to the logger to be used by the class. As of version 1.1.0
114
+ LogJam applies itself as an extension to the Ruby Object class, making the
115
+ logging facilities it provides available in any object. Prior to v1.1.0 you had
116
+ to make a call the apply() method of the LogJam module inside your class
117
+ definition. A typical call of this type might look like...
118
+
119
+ ```
120
+ # Apply logging facilties to my class.
112
121
  LogJam.apply(self, "my_logger")
122
+ ```
113
123
 
114
- This line would appear somewhere inside the definition for the class that will
115
- use logging. The first parameter to the call is the class that is to be extended
116
- with the LogJam functionality. The second parameter is the name of the logger
117
- that the class will use. Note that this parameter is optional and, if not
118
- specified or if a matching logger does not exist, the class will fall back in
119
- using the default logger.
120
-
121
- Once this line has been added to the class definition it will cause the class to
122
- be extended with three methods - two class level methods (one called log() and
123
- one called log=()) and an instance level method called log(). The log() methods
124
- retrieve the Logger instance to be used by the class instances. The log=()
125
- method allows the Logger instance associated with a class to be altered. Note
126
- the instance level log() method will only be added if an existing method with
127
- that name does not already exist on the class.
124
+ This option remains available for backward compatibility but is no longer
125
+ needed. A line like this would appear somewhere inside the definition for the
126
+ class that will use logging. The first parameter to the call is the class that
127
+ is to be extended with the LogJam functionality. The second parameter is the
128
+ name of the logger that the class will use. Note that this parameter is optional
129
+ and, if notspecified or if a matching logger does not exist, the class will fall
130
+ back in using the default logger.
131
+
132
+ From version 1.1.0 onward you no longer need to call apply. Instead LogJams
133
+ logging facilities are available in all objects. This change means that all
134
+ classes use the default logger as standard. If you want to continue to use an
135
+ explitictly named logger on a per class basis you can make a call to the
136
+ LogJam#set_logger_name() method within your class definitions. This is similar
137
+ in nature to how the apply method was used and so would look something like the
138
+ following...
139
+
140
+ ```
141
+ # Use an explicitly named logger for my class.
142
+ set_logger_name "my_logger"
143
+ ```
144
+
145
+ LogJams logging facilities consist of two class level methods (one called log()
146
+ and one called log=()) and an instance level method called log(). The log()
147
+ methods retrieve the Logger instance to be used by the class instances. The
148
+ log=() method allows the Logger instance associated with a class to be altered.
149
+ You should take care when assigning a logger in this fashion as assigning it
150
+ on one class may have an impact on many classes (e.g. if there is only a single
151
+ default logger defined in configuration).
128
152
 
129
153
  The following complete (although contrived) example gives an overview of how
130
154
  this would work...
131
155
 
156
+ ```
132
157
  require 'rubygems'
133
158
  require 'logjam'
134
159
 
135
160
  class Writer
136
- LogJam.apply(self, "echo")
137
-
138
161
  def initialize(stream=STDOUT)
139
162
  @stream = stream
140
163
  end
141
164
 
142
165
  def echo(message)
143
- Writer.log.debug("Echoed: #{message}")
166
+ log.debug("Echoed: #{message}")
144
167
  @stream.puts message
145
168
  end
146
169
  end
@@ -154,25 +177,25 @@ this would work...
154
177
  rescue => error
155
178
  puts "ERROR: #{error}\n" + error.backtrace.join("\n")
156
179
  end
180
+ ```
157
181
 
158
182
  In this example we create a Writer class that can echo a String on a stream. In
159
- doing this it also logs the message echoed at the debug level. We use the
160
- LogJam.apply() method to extend this class with logging capabilities so that, in
161
- the echo() method, we can simply call Writer.log() to get the class logger.
183
+ doing this it also logs the message echoed at the debug level. We can simply
184
+ call the log() method to get the class logger.
162
185
 
163
186
  In the later section of the code we configure the LogJam system to have a single
164
187
  Logger that writes to the echo.log file. We then create a Writer instance and
165
188
  use it to write a simple message. This message should appear on the standard
166
189
  output stream and be logged to the echo.log file.
190
+
191
+ ## Advanced Usage
167
192
 
168
- Advanced Usage
169
- --------------
170
193
  The hope would be that this library can be used in the creation of other
171
194
  libraries and allow for control of the logging generated by those libraries
172
195
  without having to dig into the workings of the library or to pass around Logger
173
- instances are constructor parameters or static data. In this case I recommend
174
- explicitly declaring logger names when using the apply() method and making the
175
- name that the library uses available with the library documentation so that the
196
+ instances as constructor parameters or static data. In this case I recommend
197
+ explicitly declaring logger names for your library classes and making the name
198
+ that the library uses available with the library documentation so that the
176
199
  libraries logging can be switched off or on as needed.
177
200
 
178
201
  It's intended that, in general, the configure() method on the LogJam module
@@ -198,8 +221,8 @@ Finally, any logger can be fetched from the library using it's name and making
198
221
  a call to the LogJam.get_logger() method. Note if you omit the name or pass in
199
222
  nil you will retrieve the libraries default logger.
200
223
 
201
- Example Configurations
202
- ----------------------
224
+ ## Example Configurations
225
+
203
226
  This section contains some example configurations. A short explanation is given
204
227
  for each configuration and then the configuration itself in Hash, YAML and JSON
205
228
  formats is provided.
@@ -209,31 +232,41 @@ to the configure method the system creates a single, default logger that writes
209
232
  everything on the standard output stream...
210
233
 
211
234
  Hash
235
+ ```
212
236
  {}
213
-
237
+ ```
238
+
214
239
  YAML
215
- ---
240
+ ```
216
241
  {}
242
+ ```
217
243
 
218
244
  JSON
245
+ ```
219
246
  {}
247
+ ```
220
248
 
221
249
  The following simple configuration writes all logging output to a file called
222
250
  application.log in the current working directory. If a logging level is not
223
251
  explicitly specified then DEBUG is the default...
224
252
 
225
253
  Hash
254
+ ```
226
255
  {:loggers => [{:default => true, :file => "application.log"}]}
256
+ ```
227
257
 
228
258
  YAML
229
- ---
259
+ ```
230
260
  :loggers:
231
261
  - :default: true
232
262
  :file: application.log
263
+ ```
233
264
 
234
265
  JSON
266
+ ```
235
267
  {"loggers": {"default": true, "file": "application.log"}}
236
-
268
+ ```
269
+
237
270
  This configuration declares two loggers. The first is called 'silent' and will
238
271
  log nothing. The silent logger is the default and so will be used for any class
239
272
  that doesn't have an explicitly named logger. The second is called 'verbose' and
@@ -243,6 +276,7 @@ the verbose logger. An class that declares it uses the 'database' logger will
243
276
  generate output while all others will be silenced.
244
277
 
245
278
  Hash
279
+ ```
246
280
  {:loggers => [{:default => true,
247
281
  :file => "STDOUT",
248
282
  :level => "UNKNOWN",
@@ -250,9 +284,10 @@ Hash
250
284
  {:file => "STDOUT",
251
285
  :name => "verbose"}],
252
286
  :aliases => {"database" => "verbose"}}
287
+ ```
253
288
 
254
289
  YAML
255
- ---
290
+ ```
256
291
  :loggers:
257
292
  - :default: true
258
293
  :file: STDOUT
@@ -262,8 +297,10 @@ YAML
262
297
  :name: verbose
263
298
  :aliases:
264
299
  database: verbose
300
+ ```
265
301
 
266
302
  JSON
303
+ ```
267
304
  {"loggers": [{"default":true,
268
305
  "file": "STDOUT",
269
306
  "level": "UNKNOWN",
@@ -271,6 +308,7 @@ JSON
271
308
  {"file": "STDOUT",
272
309
  "name": "verbose"}],
273
310
  "aliases": {"database":"verbose"}}
311
+ ```
274
312
 
275
313
  The following configuration can be used as an example of how to drive logging
276
314
  from different parts of the code to different destinations. The configuration
@@ -279,6 +317,7 @@ then declares aliases for those loggers that can be used to divide up the
279
317
  logging coming from different areas of the code.
280
318
 
281
319
  Hash
320
+ ```
282
321
  {:loggers => [{:default => true,
283
322
  :file => "./log/main.log",
284
323
  :name => "main"},
@@ -287,9 +326,10 @@ Hash
287
326
  :aliases => {"database" => "secondary",
288
327
  "model" => "secondary",
289
328
  "controller" => "main"}}
329
+ ```
290
330
 
291
331
  YAML
292
- ---
332
+ ```
293
333
  :loggers:
294
334
  - :default: true
295
335
  :file: ./log/main.log
@@ -300,8 +340,10 @@ YAML
300
340
  database: secondary
301
341
  model: secondary
302
342
  controller: main
343
+ ```
303
344
 
304
345
  JSON
346
+ ```
305
347
  {"loggers": [{"default":true,
306
348
  "file": "./log/main.log",
307
349
  "name": "main"},
@@ -310,12 +352,24 @@ JSON
310
352
  "aliases": {"database":"secondary",
311
353
  "model": "secondary",
312
354
  "controller": "main"}}
355
+ ```
356
+
357
+ ## Testing
313
358
 
314
- Testing
315
- -------
316
- LogJam uses the test-unit Ruby library for testing. The best approach to running
359
+ LogJam uses the minitest Ruby library for testing. The best approach to running
317
360
  the tests are to create a new gemset (assuming you're using RVM), do a bundle
318
361
  install on this gemset from within the LogJam root directory and then use a
319
362
  command such as the following to run the tests...
320
363
 
321
- $> ruby -I./lib -I./test ./test/unit/test_logjam.rb
364
+ ```
365
+ $> rake test:unit
366
+ ```
367
+
368
+ Individual tests can be run by including a definition for TESTS which contains
369
+ a comma separated_list of the tests to be run. For example...
370
+
371
+ ```
372
+ $> rake test:unit TESTS=object,apply
373
+ ```
374
+
375
+ ...would run only the object and apply tests.
data/lib/logjam/logjam.rb CHANGED
@@ -27,8 +27,9 @@ module LogJam
27
27
  ".#{File::SEPARATOR}config#{File::SEPARATOR}logging.json"]
28
28
 
29
29
  # Module static properties.
30
- @@logjam_modules = {}
31
- @@logjam_loggers = {}
30
+ @@logjam_modules = {}
31
+ @@logjam_loggers = {}
32
+ @@logjam_contexts = {}
32
33
 
33
34
  # This method is used to configure the LogJam module with the various loggers
34
35
  # it will use.
@@ -64,11 +65,14 @@ module LogJam
64
65
  # classes that use the same logger.
65
66
  #
66
67
  # ==== Parameters
67
- # target:: The target class that is to be extended.
68
- # name:: The name of the logger to be used by the class. Defaults to nil
69
- # to indicate use of the default logger.
70
- def self.apply(target, name=nil)
71
- target.extend(LogJam.get_module(name))
68
+ # target:: The target class that is to be extended.
69
+ # name:: The name of the logger to be used by the class. Defaults to nil
70
+ # to indicate use of the default logger.
71
+ # context:: A Hash of additional parameters that are specific to the class
72
+ # to which LogJam is being applied.
73
+ def self.apply(target, name=nil, context={})
74
+ @@logjam_contexts[target] = {}.merge(context)
75
+ target.extend(LogJam.get_module(name, @@logjam_contexts[target]))
72
76
  target.send(:define_method, :log) {LogJam.get_logger(name)} if !target.method_defined?(:log)
73
77
  end
74
78
 
@@ -100,8 +104,9 @@ module LogJam
100
104
  # not exist the default module is returned instead.
101
105
  #
102
106
  # ==== Parameters
103
- # name:: The name associated with the module to return.
104
- def self.get_module(name)
107
+ # name:: The name associated with the module to return.
108
+ # context:: The context that applies to the module to be retrieved.
109
+ def self.get_module(name, context={})
105
110
  LogJam.create_module(name)
106
111
  end
107
112
 
@@ -0,0 +1,68 @@
1
+ #! /usr/bin/env ruby
2
+ #
3
+ # Copyright (c), 2012 Peter Wood
4
+ # See the license.txt for details of the licensing of the code in this file.
5
+
6
+ module LogJam
7
+ # This class represents a specialization of the Ruby Logger class. The class
8
+ # retains a Ruby Logger instance within itself and delegates all standard
9
+ # logger calls to this instance. This allows for changes to the underlying
10
+ # logger without changing the containing one, thus bypassing people caching
11
+ # an instance.
12
+ class LogJamLogger < Logger
13
+ # Constructor for the LogJamLogger class. All parameters are passed
14
+ # straight through to create a standard Ruby Logger instance except
15
+ # when the first parameter is a Logger instance. In this case the
16
+ # Logger passed in is used rather than creating a new one.
17
+ #
18
+ # ==== Parameters
19
+ # logdev:: The log device to be used by the logger. This should
20
+ # either be a String containing a file path/name or an IO
21
+ # object that the logging details will be written to.
22
+ # shift_age:: The maximum number of old log files to retain or a String
23
+ # containing the rotation frequency for the log.
24
+ # shift_size:: The maximum size that the loggin output will be allowed
25
+ # to grow to before rotation occurs.
26
+ def initialize(logdev, shift_age=0, shift_size=1048576)
27
+ @log = (logdev.kind_of?(Logger) ? logdev : Logger.new(logdev, shift_age, shift_size))
28
+ @name = nil
29
+ @prefixes = {}
30
+ self.formatter = @log.formatter
31
+ end
32
+
33
+ # Attribute accessor/mutator declaration.
34
+ attr_accessor :name, :prefixes
35
+
36
+ # A definition of the method_missing method that passes all otherwise
37
+ # undefined method calls on to the contained logger instance.
38
+ #
39
+ # ==== Parameters
40
+ # method:: A Symbol containing the name of the method that was
41
+ # invoked but found to be missing.
42
+ # *arguments:: An array containing the arguments that were passed
43
+ # to the method call.
44
+ # &block:: Any block passed to the method call.
45
+ def method_missing(method, *arguments, &block)
46
+ if @log.responds_to? method
47
+ @log.send(method, *arguments, &block)
48
+ else
49
+ super
50
+ end
51
+ end
52
+
53
+ # This method replaces the formatter assignment method on the logger
54
+ # to allow the addition of custom fields.
55
+ #
56
+ # ==== Parameters
57
+ # &block:: The block that contains the standard formatter to be
58
+ # set on the logger.
59
+ def formatter=(&block)
60
+ @log.formatter = proc do |severity, timestamp, program, message|
61
+ if @prefixes.include?(severity) || @prefixes.include?(:default)
62
+ message = "[#{(@prefixes[severity] || @prefixes[:default])}] #{message}"
63
+ end
64
+ block.call(severity, timestamp, program, message)
65
+ end
66
+ end
67
+ end
68
+ end
@@ -0,0 +1,33 @@
1
+ #! /usr/bin/env ruby
2
+ #
3
+ # Copyright (c), 2013 Peter Wood
4
+ # See the license.txt for details of the licensing of the code in this file.
5
+
6
+ class Object
7
+ # This method provides an instance level accessor to obtain a logger. Unless
8
+ # a name is specified the logger returned is the default one.
9
+ def log
10
+ LogJam.get_logger
11
+ end
12
+
13
+ # This method provides a class level accessor to obtain a logger. Unless a
14
+ # name is specified the logger returned is the default one.
15
+ def self.log
16
+ LogJam.get_logger
17
+ end
18
+
19
+ def self.log=(logger)
20
+ LogJam.get_logger.logger = logger
21
+ end
22
+
23
+ # This method allows a class to specify the name of the logger that it uses
24
+ # once, generally within the class definition.
25
+ #
26
+ # ==== Parameters
27
+ # name:: The name of the logger used by the class.
28
+ # context:: A Hash of additional parameters that are specific to the class
29
+ # to which LogJam is being applied.
30
+ def self.set_logger_name(name, context={})
31
+ LogJam.apply(self, name, context)
32
+ end
33
+ end
@@ -1,3 +1,3 @@
1
1
  module LogJam
2
- VERSION="1.0.0"
2
+ VERSION="1.1.0"
3
3
  end
data/lib/logjam.rb CHANGED
@@ -8,4 +8,6 @@ require 'logjam/version'
8
8
  require 'logjam/exceptions'
9
9
  require 'logjam/logjam_logger'
10
10
  require 'logjam/logjam'
11
+ require 'logjam/object'
11
12
 
13
+ LogJam.configure(nil)
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: logjam
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.0
4
+ version: 1.1.0
5
5
  prerelease:
6
6
  platform: ruby
7
7
  authors:
@@ -9,7 +9,7 @@ authors:
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2013-01-26 00:00:00.000000000 Z
12
+ date: 2013-11-12 00:00:00.000000000 Z
13
13
  dependencies:
14
14
  - !ruby/object:Gem::Dependency
15
15
  name: json
@@ -35,9 +35,11 @@ extensions: []
35
35
  extra_rdoc_files: []
36
36
  files:
37
37
  - lib/logjam/version.rb
38
- - lib/logjam/logjam_logger.rb
39
38
  - lib/logjam/logjam.rb
40
39
  - lib/logjam/exceptions.rb
40
+ - lib/logjam/logjam_logger.rb
41
+ - lib/logjam/object.rb
42
+ - lib/logjam/logjam_logger2.rb
41
43
  - lib/logjam.rb
42
44
  - license.txt
43
45
  - README
@@ -61,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
61
63
  version: '0'
62
64
  requirements: []
63
65
  rubyforge_project:
64
- rubygems_version: 1.8.24
66
+ rubygems_version: 1.8.25
65
67
  signing_key:
66
68
  specification_version: 3
67
69
  summary: A library to aggregate logging.