mono_logger 1.0.1 → 1.1.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 65825574f6207c0d721ff735c1603957cf8d6e32
4
- data.tar.gz: f9b6ae2d7c62f8da7f9c4316583348b98acae1b2
3
+ metadata.gz: 7727c05cae0ac2286c24d7baf6be422ec67d6c29
4
+ data.tar.gz: be3aad2bb37089d76253b982acb058f92ff22d4a
5
5
  SHA512:
6
- metadata.gz: f74e302f3de95719aa0ba10328bf375ee276df0ea871d9b6de8b3bde933f5db4e06189ff5f1ef7e8686966c8fdf7ff08550baf30950e9f15f84ab135ee83f4ef
7
- data.tar.gz: a42768b5f0666d30f545a5aaac2e0f67dc59a577e6bb2ceb46f19d4f9bb8af5287d08cbb6dbfd6b5f66d0c4a8b9a12a1adf18b2c204606abf205b5d9c5aa09bb
6
+ metadata.gz: 75100d8e2db14e9e6c4f7821dcb23589743e2b19f0462b4b4738bf06e3bb8c72e8d0f239e6b93efcb2f588cec692f0677fd88b83e0655ab7c37e3466b9f3d3af
7
+ data.tar.gz: 69d1a4317d617870afdfcf5898f34018785f0ac2856ced89a866eca43b7181804f4e01792313c37a0308ced122401c109cfd62aff296ca400c292ab7c90e129f
@@ -0,0 +1,7 @@
1
+ language: ruby
2
+ rvm:
3
+ - 1.9.2
4
+ - 1.9.3
5
+ - 2.0.0
6
+ - jruby-19mode
7
+ - rbx-19mode
data/Rakefile CHANGED
@@ -1 +1,12 @@
1
1
  require "bundler/gem_tasks"
2
+
3
+ require 'rake/testtask'
4
+
5
+ Rake::TestTask.new do |t|
6
+ t.libs << "lib"
7
+ t.test_files = FileList['test/*_test.rb']
8
+ t.ruby_opts = ['-w']
9
+ t.verbose = true
10
+ end
11
+
12
+ task :default => :test
@@ -28,7 +28,7 @@ class MonoLogger < Logger
28
28
  #
29
29
  # Create an instance.
30
30
  #
31
- def initialize(logdev)
31
+ def initialize(logdev, shift_age=nil, shift_size=nil)
32
32
  @progname = nil
33
33
  @level = DEBUG
34
34
  @default_formatter = Formatter.new
@@ -1,5 +1,5 @@
1
1
  require 'logger'
2
2
 
3
3
  class MonoLogger < Logger
4
- VERSION = "1.0.1"
4
+ VERSION = "1.1.0"
5
5
  end
@@ -21,4 +21,5 @@ Gem::Specification.new do |spec|
21
21
 
22
22
  spec.add_development_dependency "bundler", "~> 1.3"
23
23
  spec.add_development_dependency "rake"
24
+ spec.add_development_dependency "minitest", "~> 4.0"
24
25
  end
@@ -0,0 +1,533 @@
1
+ # coding: US-ASCII
2
+ require 'test/unit'
3
+ require 'mono_logger'
4
+ require 'tempfile'
5
+
6
+ Logger = MonoLogger
7
+
8
+
9
+ class TestLoggerSeverity < Test::Unit::TestCase
10
+ def test_enum
11
+ logger_levels = Logger.constants
12
+ levels = ["WARN", "UNKNOWN", "INFO", "FATAL", "DEBUG", "ERROR"]
13
+ Logger::Severity.constants.each do |level|
14
+ assert(levels.include?(level.to_s))
15
+ assert(logger_levels.include?(level))
16
+ end
17
+ assert_equal(levels.size, Logger::Severity.constants.size)
18
+ end
19
+ end
20
+
21
+
22
+ class TestLogger < Test::Unit::TestCase
23
+ include Logger::Severity
24
+
25
+ def setup
26
+ @logger = Logger.new(nil)
27
+ end
28
+
29
+ class Log
30
+ attr_reader :label, :datetime, :pid, :severity, :progname, :msg
31
+ def initialize(line)
32
+ /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ line
33
+ @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
34
+ end
35
+ end
36
+
37
+ def log_add(logger, severity, msg, progname = nil, &block)
38
+ log(logger, :add, severity, msg, progname, &block)
39
+ end
40
+
41
+ def log(logger, msg_id, *arg, &block)
42
+ Log.new(log_raw(logger, msg_id, *arg, &block))
43
+ end
44
+
45
+ def log_raw(logger, msg_id, *arg, &block)
46
+ logdev = Tempfile.new(File.basename(__FILE__) + '.log')
47
+ logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) }
48
+ logger.__send__(msg_id, *arg, &block)
49
+ logdev.open
50
+ msg = logdev.read
51
+ logdev.close
52
+ msg
53
+ end
54
+
55
+ def test_level
56
+ @logger.level = UNKNOWN
57
+ assert_equal(UNKNOWN, @logger.level)
58
+ @logger.level = INFO
59
+ assert_equal(INFO, @logger.level)
60
+ @logger.sev_threshold = ERROR
61
+ assert_equal(ERROR, @logger.sev_threshold)
62
+ @logger.sev_threshold = WARN
63
+ assert_equal(WARN, @logger.sev_threshold)
64
+ assert_equal(WARN, @logger.level)
65
+
66
+ @logger.level = DEBUG
67
+ assert(@logger.debug?)
68
+ assert(@logger.info?)
69
+ @logger.level = INFO
70
+ assert(!@logger.debug?)
71
+ assert(@logger.info?)
72
+ assert(@logger.warn?)
73
+ @logger.level = WARN
74
+ assert(!@logger.info?)
75
+ assert(@logger.warn?)
76
+ assert(@logger.error?)
77
+ @logger.level = ERROR
78
+ assert(!@logger.warn?)
79
+ assert(@logger.error?)
80
+ assert(@logger.fatal?)
81
+ @logger.level = FATAL
82
+ assert(!@logger.error?)
83
+ assert(@logger.fatal?)
84
+ @logger.level = UNKNOWN
85
+ assert(!@logger.error?)
86
+ assert(!@logger.fatal?)
87
+ end
88
+
89
+ def test_progname
90
+ assert_nil(@logger.progname)
91
+ @logger.progname = "name"
92
+ assert_equal("name", @logger.progname)
93
+ end
94
+
95
+ def test_datetime_format
96
+ dummy = STDERR
97
+ logger = Logger.new(dummy)
98
+ log = log_add(logger, INFO, "foo")
99
+ assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+ $/, log.datetime)
100
+ logger.datetime_format = "%d%b%Y@%H:%M:%S"
101
+ log = log_add(logger, INFO, "foo")
102
+ assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime)
103
+ logger.datetime_format = ""
104
+ log = log_add(logger, INFO, "foo")
105
+ assert_match(/^$/, log.datetime)
106
+ end
107
+
108
+ def test_formatter
109
+ dummy = STDERR
110
+ logger = Logger.new(dummy)
111
+ # default
112
+ log = log(logger, :info, "foo")
113
+ assert_equal("foo\n", log.msg)
114
+ # config
115
+ logger.formatter = proc { |severity, timestamp, progname, msg|
116
+ "#{severity}:#{msg}\n\n"
117
+ }
118
+ line = log_raw(logger, :info, "foo")
119
+ assert_equal("INFO:foo\n\n", line)
120
+ # recover
121
+ logger.formatter = nil
122
+ log = log(logger, :info, "foo")
123
+ assert_equal("foo\n", log.msg)
124
+ # again
125
+ o = Object.new
126
+ def o.call(severity, timestamp, progname, msg)
127
+ "<<#{severity}-#{msg}>>\n"
128
+ end
129
+ logger.formatter = o
130
+ line = log_raw(logger, :info, "foo")
131
+ assert_equal("<""<INFO-foo>>\n", line)
132
+ end
133
+
134
+ def test_initialize
135
+ logger = Logger.new(STDERR)
136
+ assert_nil(logger.progname)
137
+ assert_equal(DEBUG, logger.level)
138
+ assert_nil(logger.datetime_format)
139
+ end
140
+
141
+ def test_add
142
+ logger = Logger.new(nil)
143
+ logger.progname = "my_progname"
144
+ assert(logger.add(INFO))
145
+ log = log_add(logger, nil, "msg")
146
+ assert_equal("ANY", log.severity)
147
+ assert_equal("my_progname", log.progname)
148
+ logger.level = WARN
149
+ assert(logger.log(INFO))
150
+ assert_nil(log_add(logger, INFO, "msg").msg)
151
+ log = log_add(logger, WARN, nil) { "msg" }
152
+ assert_equal("msg\n", log.msg)
153
+ log = log_add(logger, WARN, "") { "msg" }
154
+ assert_equal("\n", log.msg)
155
+ assert_equal("my_progname", log.progname)
156
+ log = log_add(logger, WARN, nil, "progname?")
157
+ assert_equal("progname?\n", log.msg)
158
+ assert_equal("my_progname", log.progname)
159
+ end
160
+
161
+ def test_level_log
162
+ logger = Logger.new(nil)
163
+ logger.progname = "my_progname"
164
+ log = log(logger, :debug, "custom_progname") { "msg" }
165
+ assert_equal("msg\n", log.msg)
166
+ assert_equal("custom_progname", log.progname)
167
+ assert_equal("DEBUG", log.severity)
168
+ assert_equal("D", log.label)
169
+ #
170
+ log = log(logger, :debug) { "msg_block" }
171
+ assert_equal("msg_block\n", log.msg)
172
+ assert_equal("my_progname", log.progname)
173
+ log = log(logger, :debug, "msg_inline")
174
+ assert_equal("msg_inline\n", log.msg)
175
+ assert_equal("my_progname", log.progname)
176
+ #
177
+ log = log(logger, :info, "custom_progname") { "msg" }
178
+ assert_equal("msg\n", log.msg)
179
+ assert_equal("custom_progname", log.progname)
180
+ assert_equal("INFO", log.severity)
181
+ assert_equal("I", log.label)
182
+ #
183
+ log = log(logger, :warn, "custom_progname") { "msg" }
184
+ assert_equal("msg\n", log.msg)
185
+ assert_equal("custom_progname", log.progname)
186
+ assert_equal("WARN", log.severity)
187
+ assert_equal("W", log.label)
188
+ #
189
+ log = log(logger, :error, "custom_progname") { "msg" }
190
+ assert_equal("msg\n", log.msg)
191
+ assert_equal("custom_progname", log.progname)
192
+ assert_equal("ERROR", log.severity)
193
+ assert_equal("E", log.label)
194
+ #
195
+ log = log(logger, :fatal, "custom_progname") { "msg" }
196
+ assert_equal("msg\n", log.msg)
197
+ assert_equal("custom_progname", log.progname)
198
+ assert_equal("FATAL", log.severity)
199
+ assert_equal("F", log.label)
200
+ #
201
+ log = log(logger, :unknown, "custom_progname") { "msg" }
202
+ assert_equal("msg\n", log.msg)
203
+ assert_equal("custom_progname", log.progname)
204
+ assert_equal("ANY", log.severity)
205
+ assert_equal("A", log.label)
206
+ end
207
+
208
+ def test_close
209
+ r, w = IO.pipe
210
+ assert(!w.closed?)
211
+ logger = Logger.new(w)
212
+ logger.close
213
+ assert(w.closed?)
214
+ r.close
215
+ end
216
+
217
+ class MyError < StandardError
218
+ end
219
+
220
+ class MyMsg
221
+ def inspect
222
+ "my_msg"
223
+ end
224
+ end
225
+
226
+ def test_format
227
+ logger = Logger.new(nil)
228
+ log = log_add(logger, INFO, "msg\n")
229
+ assert_equal("msg\n\n", log.msg)
230
+ begin
231
+ raise MyError.new("excn")
232
+ rescue MyError => e
233
+ log = log_add(logger, INFO, e)
234
+ assert_match(/^excn \(TestLogger::MyError\)/, log.msg)
235
+ # expects backtrace is dumped across multi lines. 10 might be changed.
236
+ assert(log.msg.split(/\n/).size >= 10)
237
+ end
238
+ log = log_add(logger, INFO, MyMsg.new)
239
+ assert_equal("my_msg\n", log.msg)
240
+ end
241
+
242
+ def test_lshift
243
+ r, w = IO.pipe
244
+ logger = Logger.new(w)
245
+ logger << "msg"
246
+ read_ready, = IO.select([r], nil, nil, 0.1)
247
+ w.close
248
+ msg = r.read
249
+ r.close
250
+ assert_equal("msg", msg)
251
+ #
252
+ r, w = IO.pipe
253
+ logger = Logger.new(w)
254
+ logger << "msg2\n\n"
255
+ read_ready, = IO.select([r], nil, nil, 0.1)
256
+ w.close
257
+ msg = r.read
258
+ r.close
259
+ assert_equal("msg2\n\n", msg)
260
+ end
261
+ end
262
+
263
+ class TestLogDevice < Test::Unit::TestCase
264
+ class LogExcnRaiser
265
+ def write(*arg)
266
+ raise 'disk is full'
267
+ end
268
+
269
+ def close
270
+ end
271
+
272
+ def stat
273
+ Object.new
274
+ end
275
+ end
276
+
277
+ def setup
278
+ @tempfile = Tempfile.new("logger")
279
+ @tempfile.close
280
+ @filename = @tempfile.path
281
+ File.unlink(@filename)
282
+ end
283
+
284
+ def teardown
285
+ @tempfile.close(true)
286
+ end
287
+
288
+ def d(log, opt = {})
289
+ Logger::LogDevice.new(log, opt)
290
+ end
291
+
292
+ def test_initialize
293
+ logdev = d(STDERR)
294
+ assert_equal(STDERR, logdev.dev)
295
+ assert_nil(logdev.filename)
296
+ assert_raises(TypeError) do
297
+ d(nil)
298
+ end
299
+ #
300
+ logdev = d(@filename)
301
+ begin
302
+ assert(File.exist?(@filename))
303
+ assert(logdev.dev.sync)
304
+ assert_equal(@filename, logdev.filename)
305
+ logdev.write('hello')
306
+ ensure
307
+ logdev.close
308
+ end
309
+ # create logfile whitch is already exist.
310
+ logdev = d(@filename)
311
+ begin
312
+ logdev.write('world')
313
+ logfile = File.read(@filename)
314
+ assert_equal(2, logfile.split(/\n/).size)
315
+ assert_match(/^helloworld$/, logfile)
316
+ ensure
317
+ logdev.close
318
+ end
319
+ end
320
+
321
+ def test_write
322
+ r, w = IO.pipe
323
+ logdev = d(w)
324
+ logdev.write("msg2\n\n")
325
+ read_ready, = IO.select([r], nil, nil, 0.1)
326
+ w.close
327
+ msg = r.read
328
+ r.close
329
+ assert_equal("msg2\n\n", msg)
330
+ #
331
+ logdev = d(LogExcnRaiser.new)
332
+ class << (stderr = '')
333
+ alias write <<
334
+ end
335
+ $stderr, stderr = stderr, $stderr
336
+ begin
337
+ assert_nothing_raised do
338
+ logdev.write('hello')
339
+ end
340
+ ensure
341
+ logdev.close
342
+ $stderr, stderr = stderr, $stderr
343
+ end
344
+ assert_equal "log writing failed. disk is full\n", stderr
345
+ end
346
+
347
+ def test_close
348
+ r, w = IO.pipe
349
+ logdev = d(w)
350
+ logdev.write("msg2\n\n")
351
+ read_ready, = IO.select([r], nil, nil, 0.1)
352
+ assert(!w.closed?)
353
+ logdev.close
354
+ assert(w.closed?)
355
+ r.close
356
+ end
357
+
358
+ def test_shifting_size
359
+ skip("shifting age doesn't work because rotation doesn't work")
360
+ tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
361
+ logfile = tmpfile.path
362
+ logfile0 = logfile + '.0'
363
+ logfile1 = logfile + '.1'
364
+ logfile2 = logfile + '.2'
365
+ logfile3 = logfile + '.3'
366
+ tmpfile.close(true)
367
+ File.unlink(logfile) if File.exist?(logfile)
368
+ File.unlink(logfile0) if File.exist?(logfile0)
369
+ File.unlink(logfile1) if File.exist?(logfile1)
370
+ File.unlink(logfile2) if File.exist?(logfile2)
371
+ logger = Logger.new(logfile, 4, 100)
372
+ logger.error("0" * 15)
373
+ assert(File.exist?(logfile))
374
+ assert(!File.exist?(logfile0))
375
+ logger.error("0" * 15)
376
+ assert(File.exist?(logfile0))
377
+ assert(!File.exist?(logfile1))
378
+ logger.error("0" * 15)
379
+ assert(File.exist?(logfile1))
380
+ assert(!File.exist?(logfile2))
381
+ logger.error("0" * 15)
382
+ assert(File.exist?(logfile2))
383
+ assert(!File.exist?(logfile3))
384
+ logger.error("0" * 15)
385
+ assert(!File.exist?(logfile3))
386
+ logger.error("0" * 15)
387
+ assert(!File.exist?(logfile3))
388
+ logger.close
389
+ File.unlink(logfile)
390
+ File.unlink(logfile0)
391
+ File.unlink(logfile1)
392
+ File.unlink(logfile2)
393
+
394
+ tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_2.log'])
395
+ logfile = tmpfile.path
396
+ logfile0 = logfile + '.0'
397
+ logfile1 = logfile + '.1'
398
+ logfile2 = logfile + '.2'
399
+ logfile3 = logfile + '.3'
400
+ tmpfile.close(true)
401
+ logger = Logger.new(logfile, 4, 150)
402
+ logger.error("0" * 15)
403
+ assert(File.exist?(logfile))
404
+ assert(!File.exist?(logfile0))
405
+ logger.error("0" * 15)
406
+ assert(!File.exist?(logfile0))
407
+ logger.error("0" * 15)
408
+ assert(File.exist?(logfile0))
409
+ assert(!File.exist?(logfile1))
410
+ logger.error("0" * 15)
411
+ assert(!File.exist?(logfile1))
412
+ logger.error("0" * 15)
413
+ assert(File.exist?(logfile1))
414
+ assert(!File.exist?(logfile2))
415
+ logger.error("0" * 15)
416
+ assert(!File.exist?(logfile2))
417
+ logger.error("0" * 15)
418
+ assert(File.exist?(logfile2))
419
+ assert(!File.exist?(logfile3))
420
+ logger.error("0" * 15)
421
+ assert(!File.exist?(logfile3))
422
+ logger.error("0" * 15)
423
+ assert(!File.exist?(logfile3))
424
+ logger.error("0" * 15)
425
+ assert(!File.exist?(logfile3))
426
+ logger.close
427
+ File.unlink(logfile)
428
+ File.unlink(logfile0)
429
+ File.unlink(logfile1)
430
+ File.unlink(logfile2)
431
+ end
432
+
433
+ def test_shifting_age_variants
434
+ skip("shifting age doesn't work because rotation doesn't work")
435
+ logger = Logger.new(@filename, 'daily')
436
+ logger.info('daily')
437
+ logger.close
438
+ logger = Logger.new(@filename, 'weekly')
439
+ logger.info('weekly')
440
+ logger.close
441
+ logger = Logger.new(@filename, 'monthly')
442
+ logger.info('monthly')
443
+ logger.close
444
+ end
445
+
446
+ def test_shifting_age
447
+ skip("shifting age doesn't work because rotation doesn't work")
448
+ # shift_age other than 'daily', 'weekly', and 'monthly' means 'everytime'
449
+ yyyymmdd = Time.now.strftime("%Y%m%d")
450
+ filename1 = @filename + ".#{yyyymmdd}"
451
+ filename2 = @filename + ".#{yyyymmdd}.1"
452
+ filename3 = @filename + ".#{yyyymmdd}.2"
453
+ begin
454
+ logger = Logger.new(@filename, 'now')
455
+ assert(File.exist?(@filename))
456
+ assert(!File.exist?(filename1))
457
+ assert(!File.exist?(filename2))
458
+ assert(!File.exist?(filename3))
459
+ logger.info("0" * 15)
460
+ assert(File.exist?(@filename))
461
+ assert(File.exist?(filename1))
462
+ assert(!File.exist?(filename2))
463
+ assert(!File.exist?(filename3))
464
+ logger.warn("0" * 15)
465
+ assert(File.exist?(@filename))
466
+ assert(File.exist?(filename1))
467
+ assert(File.exist?(filename2))
468
+ assert(!File.exist?(filename3))
469
+ logger.error("0" * 15)
470
+ assert(File.exist?(@filename))
471
+ assert(File.exist?(filename1))
472
+ assert(File.exist?(filename2))
473
+ assert(File.exist?(filename3))
474
+ ensure
475
+ logger.close if logger
476
+ [filename1, filename2, filename3].each do |filename|
477
+ File.unlink(filename) if File.exist?(filename)
478
+ end
479
+ end
480
+ end
481
+ end
482
+
483
+
484
+ class TestLoggerApplication < Test::Unit::TestCase
485
+ def setup
486
+ @app = Logger::Application.new('appname')
487
+ @tempfile = Tempfile.new("logger")
488
+ @tempfile.close
489
+ @filename = @tempfile.path
490
+ File.unlink(@filename)
491
+ end
492
+
493
+ def teardown
494
+ @tempfile.close(true)
495
+ end
496
+
497
+ def test_initialize
498
+ app = Logger::Application.new('appname')
499
+ assert_equal('appname', app.appname)
500
+ end
501
+
502
+ def test_start
503
+ @app.set_log(@filename)
504
+ begin
505
+ @app.level = Logger::UNKNOWN
506
+ @app.start # logs FATAL log
507
+ assert_equal(1, File.read(@filename).split(/\n/).size)
508
+ ensure
509
+ @app.logger.close
510
+ end
511
+ end
512
+
513
+ def test_logger
514
+ @app.level = Logger::WARN
515
+ @app.set_log(@filename)
516
+ begin
517
+ assert_equal(Logger::WARN, @app.logger.level)
518
+ ensure
519
+ @app.logger.close
520
+ end
521
+ @app.logger = logger = Logger.new(STDOUT)
522
+ assert_equal(logger, @app.logger)
523
+ assert_equal(Logger::WARN, @app.logger.level)
524
+ @app.log = @filename
525
+ begin
526
+ assert(logger != @app.logger)
527
+ assert_equal(Logger::WARN, @app.logger.level)
528
+ ensure
529
+ @app.logger.close
530
+ end
531
+ end
532
+ end
533
+
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: mono_logger
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.1
4
+ version: 1.1.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Steve Klabnik
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2013-04-08 00:00:00.000000000 Z
11
+ date: 2013-05-19 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler
@@ -38,6 +38,20 @@ dependencies:
38
38
  - - '>='
39
39
  - !ruby/object:Gem::Version
40
40
  version: '0'
41
+ - !ruby/object:Gem::Dependency
42
+ name: minitest
43
+ requirement: !ruby/object:Gem::Requirement
44
+ requirements:
45
+ - - ~>
46
+ - !ruby/object:Gem::Version
47
+ version: '4.0'
48
+ type: :development
49
+ prerelease: false
50
+ version_requirements: !ruby/object:Gem::Requirement
51
+ requirements:
52
+ - - ~>
53
+ - !ruby/object:Gem::Version
54
+ version: '4.0'
41
55
  description: A lock-free logger compatible with Ruby 2.0. Ruby does not allow you
42
56
  to request a lock in a trap handler because that could deadlock, so Logger is not
43
57
  sufficient.
@@ -48,6 +62,7 @@ extensions: []
48
62
  extra_rdoc_files: []
49
63
  files:
50
64
  - .gitignore
65
+ - .travis.yml
51
66
  - Gemfile
52
67
  - LICENSE.txt
53
68
  - README.md
@@ -55,6 +70,7 @@ files:
55
70
  - lib/mono_logger.rb
56
71
  - lib/mono_logger/version.rb
57
72
  - mono_logger.gemspec
73
+ - test/mri_logger_test.rb
58
74
  homepage: http://github.com/steveklabnik/mono_logger
59
75
  licenses:
60
76
  - MIT
@@ -79,5 +95,6 @@ rubygems_version: 2.0.0
79
95
  signing_key:
80
96
  specification_version: 4
81
97
  summary: A lock-free logger compatible with Ruby 2.0.
82
- test_files: []
98
+ test_files:
99
+ - test/mri_logger_test.rb
83
100
  has_rdoc: