graylog2-resque 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/.gitignore ADDED
@@ -0,0 +1,7 @@
1
+ *.gem
2
+ .bundle
3
+ Gemfile.lock
4
+ pkg/*
5
+ spec/dump.rdb
6
+ spec/redis-server.log
7
+ spec/redis.pid
data/CHANGELOG ADDED
@@ -0,0 +1,4 @@
1
+ 0.5.0
2
+ -----
3
+
4
+ Initial version
data/Gemfile ADDED
@@ -0,0 +1,4 @@
1
+ source "http://rubygems.org"
2
+
3
+ # Specify your gem's dependencies in graylog2-resque.gemspec
4
+ gemspec
data/LICENSE ADDED
@@ -0,0 +1,20 @@
1
+ Copyright (c) 2010 Matt Conway (matt@conwaysplace.com)
2
+
3
+ Permission is hereby granted, free of charge, to any person obtaining
4
+ a copy of this software and associated documentation files (the
5
+ "Software"), to deal in the Software without restriction, including
6
+ without limitation the rights to use, copy, modify, merge, publish,
7
+ distribute, sublicense, and/or sell copies of the Software, and to
8
+ permit persons to whom the Software is furnished to do so, subject to
9
+ the following conditions:
10
+
11
+ The above copyright notice and this permission notice shall be
12
+ included in all copies or substantial portions of the Software.
13
+
14
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
data/README.md ADDED
@@ -0,0 +1,40 @@
1
+ graylog2-resque
2
+ ===============
3
+
4
+ This gem is a failure handler plugin for [Resque][0] that sends resque failures to [graylog2][1]
5
+
6
+ Install
7
+ -------
8
+
9
+ gem install graylog2-resque
10
+ or add to your Gemfile
11
+
12
+ To use
13
+ ------
14
+
15
+ Graylog2::Resque::FailureHandler.configure do |config|
16
+ # required
17
+ config.gelf_server = "server"
18
+ config.gelf_port = "port"
19
+
20
+ # optional
21
+ # config.host = "myhost"
22
+ # config.facility = "rails_worker_exceptions"
23
+ # config.level = GELF::FATAL
24
+ # config.max_chunk_size = 'LAN'
25
+ end
26
+
27
+ Author
28
+ ------
29
+
30
+ Matt Conway :: matt@conwaysplace.com :: @mattconway
31
+
32
+ Copyright
33
+ ---------
34
+
35
+ Copyright (c) 2012 Matt Conway. See LICENSE for details.
36
+
37
+ [0]: http://github.com/defunkt/resque
38
+ [1]: http://graylog2.org
39
+
40
+
data/Rakefile ADDED
@@ -0,0 +1,66 @@
1
+ require "bundler/gem_tasks"
2
+
3
+ task :my_release => ['changelog', 'release'] do
4
+ end
5
+
6
+ task :changelog do
7
+
8
+ helper = Bundler::GemHelper.new(Dir.pwd)
9
+ version = "v#{helper.gemspec.version}"
10
+
11
+ changelog_file = 'CHANGELOG'
12
+ entries = ""
13
+
14
+ # Get a list of current tags
15
+ tags = `git tag -l`.split
16
+ tags = tags.sort_by {|t| t[1..-1].split(".").collect {|s| s.to_i } }
17
+ newest_tag = tags[-1]
18
+
19
+ if version == newest_tag
20
+ puts "You need to update version, same as most recent tag: #{version}"
21
+ exit
22
+ end
23
+
24
+ # If we already have a changelog, make the last tag be the
25
+ # last one in the changelog, and the next one be the one
26
+ # following that in the tag list
27
+ newest_changelog_version = nil
28
+ if File.exist?(changelog_file)
29
+ entries = File.read(changelog_file)
30
+ head = entries.split.first
31
+ if head =~ /\d\.\d\.\d/
32
+ newest_changelog_version = "v#{head}"
33
+
34
+ if version == newest_changelog_version
35
+ puts "You need to update version, same as most recent changelog: #{version}"
36
+ exit
37
+ end
38
+
39
+ end
40
+ end
41
+
42
+ # Generate changelog from repo
43
+ log=`git log --pretty='format:%s <%h> [%cn]' #{newest_tag}..HEAD`
44
+
45
+ # Strip out maintenance entries
46
+ log = log.lines.to_a.delete_if do |l|
47
+ l =~ /^Regenerated? gemspec/ ||
48
+ l =~ /^version bump/i ||
49
+ l =~ /^Updated changelog/ ||
50
+ l =~ /^Merged? branch/
51
+ end
52
+
53
+ # Write out changelog file
54
+ File.open(changelog_file, 'w') do |out|
55
+ out.puts version.gsub(/^v/, '')
56
+ out.puts "-----"
57
+ out.puts "\n"
58
+ out.puts log
59
+ out.puts "\n"
60
+ out.puts entries
61
+ end
62
+
63
+ # Commit and push
64
+ sh "git ci -m'Updated changelog' #{changelog_file}"
65
+ sh "git push"
66
+ end
@@ -0,0 +1,26 @@
1
+ # -*- encoding: utf-8 -*-
2
+ $:.push File.expand_path("../lib", __FILE__)
3
+ require "graylog2-resque/version"
4
+
5
+ Gem::Specification.new do |s|
6
+ s.name = "graylog2-resque"
7
+ s.version = Graylog2::Resque::VERSION
8
+ s.authors = ["Matt Conway"]
9
+ s.email = ["wr0ngway@yahoo.com"]
10
+ s.homepage = ""
11
+ s.summary = %q{A resque failure handler that sends failures to the graylog2 log management facility }
12
+ s.description = %q{A resque failure handler that sends failures to the graylog2 log management facility }
13
+
14
+ s.rubyforge_project = "graylog2-resque"
15
+
16
+ s.files = `git ls-files`.split("\n")
17
+ s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
18
+ s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
19
+ s.require_paths = ["lib"]
20
+
21
+ # specify any dependencies here; for example:
22
+ s.add_development_dependency "rake"
23
+ s.add_development_dependency "rspec"
24
+ s.add_dependency "gelf"
25
+ s.add_dependency "resque"
26
+ end
@@ -0,0 +1,2 @@
1
+ require "graylog2-resque/version"
2
+ require "graylog2-resque/failure_handler"
@@ -0,0 +1,72 @@
1
+ require 'resque'
2
+ require 'gelf'
3
+
4
+ module Graylog2
5
+ module Resque
6
+
7
+ # A Failure backend that sends exceptions to Graylog
8
+ #
9
+ # Graylog2::Resque::FailureHandler.configure do |config|
10
+ # # required
11
+ # config.gelf_server = "server"
12
+ # config.gelf_port = "port"
13
+ #
14
+ # # optional
15
+ # # config.host = "myhost"
16
+ # # config.facility = "rails_worker_exceptions"
17
+ # # config.level = GELF::FATAL
18
+ # # config.max_chunk_size = 'LAN'
19
+ # end
20
+ #
21
+ class FailureHandler < ::Resque::Failure::Base
22
+
23
+ class << self
24
+ # required
25
+ attr_accessor :gelf_server, :gelf_port
26
+ # optional
27
+ attr_accessor :facility, :level, :host, :max_chunk_size
28
+ end
29
+
30
+ def self.configure
31
+ yield self
32
+ raise "Graylog server and port needed for resque failure handler" unless gelf_server && gelf_port
33
+ ::Resque::Failure.backend = self
34
+ end
35
+
36
+ def save
37
+ begin
38
+ data = {}
39
+
40
+ trace = Array(exception.backtrace)
41
+ if trace[0]
42
+ data[:file] = trace[0].split(":")[0]
43
+ data[:line] = trace[0].split(":")[1]
44
+ end
45
+ data[:facility] = self.class.facility if self.class.facility
46
+ data[:level] = self.class.level || GELF::FATAL
47
+ data[:host] = self.class.host if self.class.host
48
+
49
+ data[:short_message] = "#{exception.class}: #{exception.message}"
50
+ data[:full_message] = "Backtrace:\n" + trace.join("\n")
51
+ data["_resque_worker"] = worker.to_s
52
+ data["_resque_queue"] = queue.to_s
53
+ data["_resque_class"] = payload['class'].to_s
54
+ data["_resque_args"] = payload['args'].inspect.to_s
55
+
56
+ notifier = GELF::Notifier.new(self.class.gelf_server, self.class.gelf_port, self.class.max_chunk_size || 'LAN')
57
+ notifier.notify!(data)
58
+ rescue Exception => e
59
+ puts "Failed to send resque failure to graylog: #{e}"
60
+ end
61
+ end
62
+
63
+ def self.count
64
+ # We can't get the total # of errors from graylog so we fake it
65
+ # by asking Resque how many errors it has seen.
66
+ Stat[:failed]
67
+ end
68
+
69
+ end
70
+
71
+ end
72
+ end
@@ -0,0 +1,5 @@
1
+ module Graylog2
2
+ module Resque
3
+ VERSION = "0.5.0"
4
+ end
5
+ end
@@ -0,0 +1,312 @@
1
+ # Redis configuration file example
2
+
3
+ # Note on units: when memory size is needed, it is possible to specifiy
4
+ # it in the usual form of 1k 5GB 4M and so forth:
5
+ #
6
+ # 1k => 1000 bytes
7
+ # 1kb => 1024 bytes
8
+ # 1m => 1000000 bytes
9
+ # 1mb => 1024*1024 bytes
10
+ # 1g => 1000000000 bytes
11
+ # 1gb => 1024*1024*1024 bytes
12
+ #
13
+ # units are case insensitive so 1GB 1Gb 1gB are all the same.
14
+
15
+ # By default Redis does not run as a daemon. Use 'yes' if you need it.
16
+ # Note that Redis will write a pid file in ./tmp/run/redis.pid when daemonized.
17
+ daemonize yes
18
+
19
+ # When running daemonized, Redis writes a pid file in ./tmp/run/redis.pid by
20
+ # default. You can specify a custom pid file location here.
21
+ pidfile ./redis.pid
22
+
23
+ # Accept connections on the specified port, default is 6379
24
+ port 9736
25
+
26
+ # If you want you can bind a single interface, if the bind option is not
27
+ # specified all the interfaces will listen for incoming connections.
28
+ #
29
+ bind 127.0.0.1
30
+
31
+ # Close the connection after a client is idle for N seconds (0 to disable)
32
+ timeout 300
33
+
34
+ # Set server verbosity to 'debug'
35
+ # it can be one of:
36
+ # debug (a lot of information, useful for development/testing)
37
+ # verbose (many rarely useful info, but not a mess like the debug level)
38
+ # notice (moderately verbose, what you want in production probably)
39
+ # warning (only very important / critical messages are logged)
40
+ loglevel verbose
41
+
42
+ # Specify the log file name. Also 'stdout' can be used to force
43
+ # Redis to log on the standard output. Note that if you use standard
44
+ # output for logging but daemonize, logs will be sent to /dev/null
45
+ logfile ./redis-server.log
46
+
47
+ # Set the number of databases. The default database is DB 0, you can select
48
+ # a different one on a per-connection basis using SELECT <dbid> where
49
+ # dbid is a number between 0 and 'databases'-1
50
+ databases 16
51
+
52
+ ################################ SNAPSHOTTING #################################
53
+ #
54
+ # Save the DB on disk:
55
+ #
56
+ # save <seconds> <changes>
57
+ #
58
+ # Will save the DB if both the given number of seconds and the given
59
+ # number of write operations against the DB occurred.
60
+ #
61
+ # In the example below the behaviour will be to save:
62
+ # after 900 sec (15 min) if at least 1 key changed
63
+ # after 300 sec (5 min) if at least 10 keys changed
64
+ # after 60 sec if at least 10000 keys changed
65
+ #
66
+ # Note: you can disable saving at all commenting all the "save" lines.
67
+
68
+ save 900 1
69
+ save 300 10
70
+ save 60 10000
71
+
72
+ # Compress string objects using LZF when dump .rdb databases?
73
+ # For default that's set to 'yes' as it's almost always a win.
74
+ # If you want to save some CPU in the saving child set it to 'no' but
75
+ # the dataset will likely be bigger if you have compressible values or keys.
76
+ rdbcompression yes
77
+
78
+ # The filename where to dump the DB
79
+ dbfilename dump.rdb
80
+
81
+ # The working directory.
82
+ #
83
+ # The DB will be written inside this directory, with the filename specified
84
+ # above using the 'dbfilename' configuration directive.
85
+ #
86
+ # Also the Append Only File will be created inside this directory.
87
+ #
88
+ # Note that you must specify a directory here, not a file name.
89
+ dir .
90
+
91
+ ################################# REPLICATION #################################
92
+
93
+ # Master-Slave replication. Use slaveof to make a Redis instance a copy of
94
+ # another Redis server. Note that the configuration is local to the slave
95
+ # so for example it is possible to configure the slave to save the DB with a
96
+ # different interval, or to listen to another port, and so on.
97
+ #
98
+ # slaveof <masterip> <masterport>
99
+
100
+ # If the master is password protected (using the "requirepass" configuration
101
+ # directive below) it is possible to tell the slave to authenticate before
102
+ # starting the replication synchronization process, otherwise the master will
103
+ # refuse the slave request.
104
+ #
105
+ # masterauth <master-password>
106
+
107
+ ################################## SECURITY ###################################
108
+
109
+ # Require clients to issue AUTH <PASSWORD> before processing any other
110
+ # commands. This might be useful in environments in which you do not trust
111
+ # others with access to the host running redis-server.
112
+ #
113
+ # This should stay commented out for backward compatibility and because most
114
+ # people do not need auth (e.g. they run their own servers).
115
+ #
116
+ # Warning: since Redis is pretty fast an outside user can try up to
117
+ # 150k passwords per second against a good box. This means that you should
118
+ # use a very strong password otherwise it will be very easy to break.
119
+ #
120
+ # requirepass foobared
121
+
122
+ ################################### LIMITS ####################################
123
+
124
+ # Set the max number of connected clients at the same time. By default there
125
+ # is no limit, and it's up to the number of file descriptors the Redis process
126
+ # is able to open. The special value '0' means no limits.
127
+ # Once the limit is reached Redis will close all the new connections sending
128
+ # an error 'max number of clients reached'.
129
+ #
130
+ # maxclients 128
131
+
132
+ # Don't use more memory than the specified amount of bytes.
133
+ # When the memory limit is reached Redis will try to remove keys with an
134
+ # EXPIRE set. It will try to start freeing keys that are going to expire
135
+ # in little time and preserve keys with a longer time to live.
136
+ # Redis will also try to remove objects from free lists if possible.
137
+ #
138
+ # If all this fails, Redis will start to reply with errors to commands
139
+ # that will use more memory, like SET, LPUSH, and so on, and will continue
140
+ # to reply to most read-only commands like GET.
141
+ #
142
+ # WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
143
+ # 'state' server or cache, not as a real DB. When Redis is used as a real
144
+ # database the memory usage will grow over the weeks, it will be obvious if
145
+ # it is going to use too much memory in the long run, and you'll have the time
146
+ # to upgrade. With maxmemory after the limit is reached you'll start to get
147
+ # errors for write operations, and this may even lead to DB inconsistency.
148
+ #
149
+ # maxmemory <bytes>
150
+
151
+ ############################## APPEND ONLY MODE ###############################
152
+
153
+ # By default Redis asynchronously dumps the dataset on disk. If you can live
154
+ # with the idea that the latest records will be lost if something like a crash
155
+ # happens this is the preferred way to run Redis. If instead you care a lot
156
+ # about your data and don't want to that a single record can get lost you should
157
+ # enable the append only mode: when this mode is enabled Redis will append
158
+ # every write operation received in the file appendonly.aof. This file will
159
+ # be read on startup in order to rebuild the full dataset in memory.
160
+ #
161
+ # Note that you can have both the async dumps and the append only file if you
162
+ # like (you have to comment the "save" statements above to disable the dumps).
163
+ # Still if append only mode is enabled Redis will load the data from the
164
+ # log file at startup ignoring the dump.rdb file.
165
+ #
166
+ # IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
167
+ # log file in background when it gets too big.
168
+
169
+ appendonly no
170
+
171
+ # The name of the append only file (default: "appendonly.aof")
172
+ # appendfilename appendonly.aof
173
+
174
+ # The fsync() call tells the Operating System to actually write data on disk
175
+ # instead to wait for more data in the output buffer. Some OS will really flush
176
+ # data on disk, some other OS will just try to do it ASAP.
177
+ #
178
+ # Redis supports three different modes:
179
+ #
180
+ # no: don't fsync, just let the OS flush the data when it wants. Faster.
181
+ # always: fsync after every write to the append only log . Slow, Safest.
182
+ # everysec: fsync only if one second passed since the last fsync. Compromise.
183
+ #
184
+ # The default is "everysec" that's usually the right compromise between
185
+ # speed and data safety. It's up to you to understand if you can relax this to
186
+ # "no" that will will let the operating system flush the output buffer when
187
+ # it wants, for better performances (but if you can live with the idea of
188
+ # some data loss consider the default persistence mode that's snapshotting),
189
+ # or on the contrary, use "always" that's very slow but a bit safer than
190
+ # everysec.
191
+ #
192
+ # If unsure, use "everysec".
193
+
194
+ # appendfsync always
195
+ appendfsync everysec
196
+ # appendfsync no
197
+
198
+ ################################ VIRTUAL MEMORY ###############################
199
+
200
+ # Virtual Memory allows Redis to work with datasets bigger than the actual
201
+ # amount of RAM needed to hold the whole dataset in memory.
202
+ # In order to do so very used keys are taken in memory while the other keys
203
+ # are swapped into a swap file, similarly to what operating systems do
204
+ # with memory pages.
205
+ #
206
+ # To enable VM just set 'vm-enabled' to yes, and set the following three
207
+ # VM parameters accordingly to your needs.
208
+
209
+ vm-enabled no
210
+ # vm-enabled yes
211
+
212
+ # This is the path of the Redis swap file. As you can guess, swap files
213
+ # can't be shared by different Redis instances, so make sure to use a swap
214
+ # file for every redis process you are running. Redis will complain if the
215
+ # swap file is already in use.
216
+ #
217
+ # The best kind of storage for the Redis swap file (that's accessed at random)
218
+ # is a Solid State Disk (SSD).
219
+ #
220
+ # *** WARNING *** if you are using a shared hosting the default of putting
221
+ # the swap file under /tmp is not secure. Create a dir with access granted
222
+ # only to Redis user and configure Redis to create the swap file there.
223
+ vm-swap-file ./tmp/redis.swap
224
+
225
+ # vm-max-memory configures the VM to use at max the specified amount of
226
+ # RAM. Everything that deos not fit will be swapped on disk *if* possible, that
227
+ # is, if there is still enough contiguous space in the swap file.
228
+ #
229
+ # With vm-max-memory 0 the system will swap everything it can. Not a good
230
+ # default, just specify the max amount of RAM you can in bytes, but it's
231
+ # better to leave some margin. For instance specify an amount of RAM
232
+ # that's more or less between 60 and 80% of your free RAM.
233
+ vm-max-memory 0
234
+
235
+ # Redis swap files is split into pages. An object can be saved using multiple
236
+ # contiguous pages, but pages can't be shared between different objects.
237
+ # So if your page is too big, small objects swapped out on disk will waste
238
+ # a lot of space. If you page is too small, there is less space in the swap
239
+ # file (assuming you configured the same number of total swap file pages).
240
+ #
241
+ # If you use a lot of small objects, use a page size of 64 or 32 bytes.
242
+ # If you use a lot of big objects, use a bigger page size.
243
+ # If unsure, use the default :)
244
+ vm-page-size 32
245
+
246
+ # Number of total memory pages in the swap file.
247
+ # Given that the page table (a bitmap of free/used pages) is taken in memory,
248
+ # every 8 pages on disk will consume 1 byte of RAM.
249
+ #
250
+ # The total swap size is vm-page-size * vm-pages
251
+ #
252
+ # With the default of 32-bytes memory pages and 134217728 pages Redis will
253
+ # use a 4 GB swap file, that will use 16 MB of RAM for the page table.
254
+ #
255
+ # It's better to use the smallest acceptable value for your application,
256
+ # but the default is large in order to work in most conditions.
257
+ vm-pages 134217728
258
+
259
+ # Max number of VM I/O threads running at the same time.
260
+ # This threads are used to read/write data from/to swap file, since they
261
+ # also encode and decode objects from disk to memory or the reverse, a bigger
262
+ # number of threads can help with big objects even if they can't help with
263
+ # I/O itself as the physical device may not be able to couple with many
264
+ # reads/writes operations at the same time.
265
+ #
266
+ # The special value of 0 turn off threaded I/O and enables the blocking
267
+ # Virtual Memory implementation.
268
+ vm-max-threads 4
269
+
270
+ ############################### ADVANCED CONFIG ###############################
271
+
272
+ # Glue small output buffers together in order to send small replies in a
273
+ # single TCP packet. Uses a bit more CPU but most of the times it is a win
274
+ # in terms of number of queries per second. Use 'yes' if unsure.
275
+ glueoutputbuf yes
276
+
277
+ # Hashes are encoded in a special way (much more memory efficient) when they
278
+ # have at max a given numer of elements, and the biggest element does not
279
+ # exceed a given threshold. You can configure this limits with the following
280
+ # configuration directives.
281
+ hash-max-zipmap-entries 64
282
+ hash-max-zipmap-value 512
283
+
284
+ # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
285
+ # order to help rehashing the main Redis hash table (the one mapping top-level
286
+ # keys to values). The hash table implementation redis uses (see dict.c)
287
+ # performs a lazy rehashing: the more operation you run into an hash table
288
+ # that is rhashing, the more rehashing "steps" are performed, so if the
289
+ # server is idle the rehashing is never complete and some more memory is used
290
+ # by the hash table.
291
+ #
292
+ # The default is to use this millisecond 10 times every second in order to
293
+ # active rehashing the main dictionaries, freeing memory when possible.
294
+ #
295
+ # If unsure:
296
+ # use "activerehashing no" if you have hard latency requirements and it is
297
+ # not a good thing in your environment that Redis can reply form time to time
298
+ # to queries with 2 milliseconds delay.
299
+ #
300
+ # use "activerehashing yes" if you don't have such hard requirements but
301
+ # want to free memory asap when possible.
302
+ activerehashing yes
303
+
304
+ ################################## INCLUDES ###################################
305
+
306
+ # Include one or more other config files here. This is useful if you
307
+ # have a standard template that goes to all redis server but also need
308
+ # to customize a few per-server settings. Include files can include
309
+ # other files, so use this wisely.
310
+ #
311
+ # include /path/to/local.conf
312
+ # include /path/to/other.conf
@@ -0,0 +1,124 @@
1
+ require "spec_helper"
2
+
3
+ describe Graylog2::Resque::FailureHandler do
4
+ include PerformJob
5
+
6
+ context "configure" do
7
+
8
+ it "should raise if nothing in config" do
9
+ lambda {
10
+ Graylog2::Resque::FailureHandler.configure do |config|
11
+ config.gelf_server = nil
12
+ config.gelf_port = nil
13
+ end
14
+ }.should raise_error("Graylog server and port needed for resque failure handler")
15
+ end
16
+
17
+ it "should raise if no gelf_port in config" do
18
+ lambda {
19
+ Graylog2::Resque::FailureHandler.configure do |config|
20
+ config.gelf_server = 'localhost'
21
+ config.gelf_port = nil
22
+ end
23
+ }.should raise_error("Graylog server and port needed for resque failure handler")
24
+ end
25
+
26
+ it "should raise if no gelf_server in config" do
27
+ lambda {
28
+ Graylog2::Resque::FailureHandler.configure do |config|
29
+ config.gelf_server = nil
30
+ config.gelf_port = 1234
31
+ end
32
+ }.should raise_error("Graylog server and port needed for resque failure handler")
33
+ end
34
+
35
+ it "should not raise if config valid" do
36
+ lambda {
37
+ Graylog2::Resque::FailureHandler.configure do |config|
38
+ config.gelf_server = 'localhost'
39
+ config.gelf_port = 1234
40
+ end
41
+ }.should_not raise_exception
42
+ end
43
+
44
+ it "should allow setting/getting global config" do
45
+ Graylog2::Resque::FailureHandler.gelf_server = nil
46
+ Graylog2::Resque::FailureHandler.gelf_port = nil
47
+ Graylog2::Resque::FailureHandler.facility = nil
48
+ Graylog2::Resque::FailureHandler.level = nil
49
+ Graylog2::Resque::FailureHandler.host = nil
50
+ Graylog2::Resque::FailureHandler.max_chunk_size = nil
51
+
52
+ Graylog2::Resque::FailureHandler.configure do |config|
53
+ config.gelf_server = 'localhost'
54
+ config.gelf_port = 1234
55
+ config.facility = 'somefacility'
56
+ config.level = GELF::WARN
57
+ config.host = 'somehost'
58
+ config.max_chunk_size = 'LAN'
59
+ end
60
+
61
+ Graylog2::Resque::FailureHandler.gelf_server.should == 'localhost'
62
+ Graylog2::Resque::FailureHandler.gelf_port.should == 1234
63
+ Graylog2::Resque::FailureHandler.facility.should == 'somefacility'
64
+ Graylog2::Resque::FailureHandler.level.should == GELF::WARN
65
+ Graylog2::Resque::FailureHandler.host.should == 'somehost'
66
+ Graylog2::Resque::FailureHandler.max_chunk_size.should == 'LAN'
67
+ end
68
+
69
+ it "should set failure handler" do
70
+ ::Resque::Failure.backend = nil
71
+
72
+ Graylog2::Resque::FailureHandler.configure do |config|
73
+ config.gelf_server = 'localhost'
74
+ config.gelf_port = 1234
75
+ end
76
+
77
+ ::Resque::Failure.backend.should == Graylog2::Resque::FailureHandler
78
+ end
79
+
80
+ end
81
+
82
+ context "handling resque failures" do
83
+
84
+ class SomeJob
85
+ def self.perform(*args)
86
+ raise "I failed"
87
+ end
88
+ end
89
+
90
+ before(:each) do
91
+ Graylog2::Resque::FailureHandler.configure do |config|
92
+ config.gelf_server = 'localhost'
93
+ config.gelf_port = 1234
94
+ config.facility = 'somefacility'
95
+ config.level = GELF::WARN
96
+ config.host = 'somehost'
97
+ config.max_chunk_size = 'WAN'
98
+ end
99
+ end
100
+
101
+ it "triggers failure handler" do
102
+
103
+ notifier = double("notifier")
104
+ GELF::Notifier.should_receive(:new).with('localhost', 1234, 'WAN').and_return(notifier)
105
+ notifier.should_receive(:notify!) do |data|
106
+ data[:file].should == __FILE__
107
+ data[:line].should =~ /\d+/
108
+ data[:facility].should == 'somefacility'
109
+ data[:level].should == GELF::WARN
110
+ data[:host].should == 'somehost'
111
+ data[:short_message].should == 'RuntimeError: I failed'
112
+ data[:full_message].should =~ /Backtrace:.*/m
113
+ data["_resque_worker"].should == ""
114
+ data["_resque_queue"].should == "somequeue"
115
+ data["_resque_class"].should == "SomeJob"
116
+ data["_resque_args"].should == "[\"foo\"]"
117
+ end
118
+
119
+ run_resque_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
120
+ end
121
+
122
+ end
123
+
124
+ end
@@ -0,0 +1,63 @@
1
+ require 'rspec'
2
+ require 'graylog2-resque'
3
+
4
+ spec_dir = File.dirname(File.expand_path(__FILE__))
5
+ REDIS_CMD = "redis-server #{spec_dir}/redis-test.conf"
6
+
7
+ puts "Starting redis for testing at localhost:9736..."
8
+ puts `cd #{spec_dir}; #{REDIS_CMD}`
9
+ Resque.redis = 'localhost:9736'
10
+
11
+ # Schedule the redis server for shutdown when tests are all finished.
12
+ at_exit do
13
+ pid = File.read("#{spec_dir}/redis.pid").to_i rescue nil
14
+ system ("kill #{pid}") if pid != 0
15
+ end
16
+
17
+ ##
18
+ # Helper to perform job classes
19
+ #
20
+ module PerformJob
21
+
22
+ def run_resque_job(job_class, *job_args)
23
+ opts = job_args.last.is_a?(Hash) ? job_args.pop : {}
24
+ queue = opts[:queue] || Resque.queue_from_class(job_class)
25
+
26
+ Resque::Job.create(queue, job_class, *job_args)
27
+
28
+ run_resque_queue(queue, opts)
29
+ end
30
+
31
+ def run_resque_queue(queue, opts={})
32
+ worker = Resque::Worker.new(queue)
33
+ worker.very_verbose = true if opts[:verbose]
34
+
35
+ # do a single job then shutdown
36
+ def worker.done_working
37
+ super
38
+ shutdown
39
+ end
40
+
41
+ if opts[:inline]
42
+ job = worker.reserve
43
+ worker.perform(job)
44
+ else
45
+ worker.work(0)
46
+ end
47
+ end
48
+
49
+ def dump_redis
50
+ result = {}
51
+ Resque.redis.keys("*").each do |key|
52
+ type = Resque.redis.type(key)
53
+ result[key] = case type
54
+ when 'string' then Resque.redis.get(key)
55
+ when 'list' then Resque.redis.lrange(key, 0, -1)
56
+ when 'set' then Resque.redis.smembers(key)
57
+ else type
58
+ end
59
+ end
60
+ return result
61
+ end
62
+
63
+ end
metadata ADDED
@@ -0,0 +1,108 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: graylog2-resque
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.5.0
5
+ prerelease:
6
+ platform: ruby
7
+ authors:
8
+ - Matt Conway
9
+ autorequire:
10
+ bindir: bin
11
+ cert_chain: []
12
+ date: 2012-01-26 00:00:00.000000000Z
13
+ dependencies:
14
+ - !ruby/object:Gem::Dependency
15
+ name: rake
16
+ requirement: &2240396860 !ruby/object:Gem::Requirement
17
+ none: false
18
+ requirements:
19
+ - - ! '>='
20
+ - !ruby/object:Gem::Version
21
+ version: '0'
22
+ type: :development
23
+ prerelease: false
24
+ version_requirements: *2240396860
25
+ - !ruby/object:Gem::Dependency
26
+ name: rspec
27
+ requirement: &2240396400 !ruby/object:Gem::Requirement
28
+ none: false
29
+ requirements:
30
+ - - ! '>='
31
+ - !ruby/object:Gem::Version
32
+ version: '0'
33
+ type: :development
34
+ prerelease: false
35
+ version_requirements: *2240396400
36
+ - !ruby/object:Gem::Dependency
37
+ name: gelf
38
+ requirement: &2240395960 !ruby/object:Gem::Requirement
39
+ none: false
40
+ requirements:
41
+ - - ! '>='
42
+ - !ruby/object:Gem::Version
43
+ version: '0'
44
+ type: :runtime
45
+ prerelease: false
46
+ version_requirements: *2240395960
47
+ - !ruby/object:Gem::Dependency
48
+ name: resque
49
+ requirement: &2240395480 !ruby/object:Gem::Requirement
50
+ none: false
51
+ requirements:
52
+ - - ! '>='
53
+ - !ruby/object:Gem::Version
54
+ version: '0'
55
+ type: :runtime
56
+ prerelease: false
57
+ version_requirements: *2240395480
58
+ description: ! 'A resque failure handler that sends failures to the graylog2 log management
59
+ facility '
60
+ email:
61
+ - wr0ngway@yahoo.com
62
+ executables: []
63
+ extensions: []
64
+ extra_rdoc_files: []
65
+ files:
66
+ - .gitignore
67
+ - CHANGELOG
68
+ - Gemfile
69
+ - LICENSE
70
+ - README.md
71
+ - Rakefile
72
+ - graylog2-resque.gemspec
73
+ - lib/graylog2-resque.rb
74
+ - lib/graylog2-resque/failure_handler.rb
75
+ - lib/graylog2-resque/version.rb
76
+ - spec/redis-test.conf
77
+ - spec/resque_failure_spec.rb
78
+ - spec/spec_helper.rb
79
+ homepage: ''
80
+ licenses: []
81
+ post_install_message:
82
+ rdoc_options: []
83
+ require_paths:
84
+ - lib
85
+ required_ruby_version: !ruby/object:Gem::Requirement
86
+ none: false
87
+ requirements:
88
+ - - ! '>='
89
+ - !ruby/object:Gem::Version
90
+ version: '0'
91
+ required_rubygems_version: !ruby/object:Gem::Requirement
92
+ none: false
93
+ requirements:
94
+ - - ! '>='
95
+ - !ruby/object:Gem::Version
96
+ version: '0'
97
+ requirements: []
98
+ rubyforge_project: graylog2-resque
99
+ rubygems_version: 1.8.10
100
+ signing_key:
101
+ specification_version: 3
102
+ summary: A resque failure handler that sends failures to the graylog2 log management
103
+ facility
104
+ test_files:
105
+ - spec/redis-test.conf
106
+ - spec/resque_failure_spec.rb
107
+ - spec/spec_helper.rb
108
+ has_rdoc: