appsignal 2.9.8 → 2.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8943e834f68be414db7b15bab1980a651190b084c6270422b78230c4d3428826
-  data.tar.gz: 5f16b829fa9efd610b8040ee52103ccc31c5872cfe26d8f336548d312bc7d6b0
+  metadata.gz: e1d7fa0a46c7ba3c90ccbaca56b462644da1c3fc66efe545f86f0802351b2ee0
+  data.tar.gz: f0e5d4b31d892183aa162e0b1295e9422eed5a4d8d6f2a480b2ca376d194cd45
 SHA512:
-  metadata.gz: b75337875c59626adbcf0df2df74a9f66f0dfe5a5dc807cfd189de3d2dc529dece0d18cc88f983bee41e3ddee475e1cbfcfedbf450d1adf8bd51c92ebb1ff467
-  data.tar.gz: '09df480bcdab11e0d80e48d8872f519900d18913dabd656e56a4545132d8822cf1ba5e98394ffc10b8f739b4e01cab652602cd1483937881c6dbddfc9a56ec0c'
+  metadata.gz: d9baa71a5a0576d8244a3857232e6e25132297b52114e882f8ee01b86dbe18be2dc9232812cfd8720070b5f39fc57bd67350e53c3290ef349bd39bfa8e1d9531
+  data.tar.gz: cc6bf8d75938f2571ee8dbd5aec10ada0f87d8f7f8163e6bd200b5eb55401e3e9d79c3f3eff1cb35c8d9cfddd7716bd0041d1d73f492af5fea118ffd729b34e0

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,31 @@
+---
+name: Bug report
+about: Create a report to help us improve the project.
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+If your bug is about how AppSignal works in your app specifically we recommend you contact us at support@appsignal.com with your bug report instead.
+
+---
+
+## Describe the bug
+
+A clear and concise description of what the bug is including the code used and the exception backtrace, if any.
+
+## To Reproduce
+
+Steps to reproduce the behavior:
+
+- Using AppSignal for Ruby gem version 2.x.x
+- In my app using framework/library/gem ... version x.x.x
+- With this code:
+  ```
+  Optional: Any additional AppSignal instrumentation that was added.
+  ```
+- In this code:
+  ```
+  Your app code in which the bug occurs.
+  ```

data/.github/ISSUE_TEMPLATE/chore.md

@@ -0,0 +1,14 @@
+---
+name: Chore
+about: Create an issue for a task that needs to be performed.
+title: ''
+labels: chore
+assignees: ''
+
+---
+
+## TODO
+
+- [ ] Tasks that need to be performed
+- [ ] In order
+- [ ] To complete the chore

data/.rubocop.yml

@@ -61,6 +61,9 @@ Style/TrailingUnderscoreVariable:
 Style/Encoding: # For Ruby 1.9 as it doesn't default to UTF-8
   Enabled: false
 
+Style/Lambda:
+  EnforcedStyle: lambda
+
 Naming/FileName:
   Exclude:
     - "ext/Rakefile"

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 2.9.9
+- Fix error in the ActiveSupport::Notifications integration when a transaction
+  gets completed during event instrumentation. PR #532
+- Fix Redis constant load error. PR #543
+- Deprecate notify_of_deploy command. PR #545
+- Always call the block given to `Appsignal.monitor_transaction` and log errors
+  from the helper even when AppSignal is not active. PR #547
+
 ## 2.9.8
 - Fix Ruby 1.9 compatibility in extension installation. PR #531
 

data/Rakefile

@@ -5,15 +5,15 @@ require "fileutils"
 VERSION_MANAGERS = {
   :chruby => {
     :env => "#!/bin/bash\nsource /usr/local/opt/chruby/share/chruby/chruby.sh",
-    :switch_command => ->(version) { "chruby #{version}" }
+    :switch_command => lambda { |version| "chruby #{version}" }
   },
   :rbenv => {
     :env => "#!/bin/bash",
-    :switch_command => ->(version) { "rbenv local #{version}" }
+    :switch_command => lambda { |version| "rbenv local #{version}" }
   },
   :rvm => {
     :env => "#!/bin/bash --login",
-    :switch_command => ->(version) { "rvm use --default #{version}" }
+    :switch_command => lambda { |version| "rvm use --default #{version}" }
   }
 }.freeze
 

data/lib/appsignal/cli/notify_of_deploy.rb

@@ -60,6 +60,8 @@ module Appsignal
     #   Terminology: Deploy marker
     class NotifyOfDeploy
       class << self
+        include Appsignal::Utils::DeprecationMessage
+
         # @param options [Hash]
         # @option options :environment [String] environment to load
         #   configuration for.
@@ -85,6 +87,14 @@ module Appsignal
             },
             config
           ).transmit
+
+          puts
+          message = "This command (appsignal notify_of_deploy) has been " \
+            "deprecated in favor of the `revision` config option. Please " \
+            "see our documentation for more information on the recommended " \
+            "method: " \
+            "https://docs.appsignal.com/application/markers/deploy-markers.html"
+          deprecation_message message, Appsignal.logger
         end
 
         private

data/lib/appsignal/helpers/instrumentation.rb

@@ -57,8 +57,9 @@ module Appsignal
       # @return [Object] the value of the given block is returned.
       # @since 0.10.0
       def monitor_transaction(name, env = {})
-        return yield unless active?
-
+        # Always verify input, even when Appsignal is not active.
+        # This makes it more likely invalid arguments get flagged in test/dev
+        # environments.
         if name.start_with?("perform_job".freeze)
           namespace = Appsignal::Transaction::BACKGROUND_JOB
           request   = Appsignal::Transaction::GenericRequest.new(env)
@@ -66,9 +67,14 @@ module Appsignal
           namespace = Appsignal::Transaction::HTTP_REQUEST
           request   = ::Rack::Request.new(env)
         else
-          logger.error("Unrecognized name '#{name}'")
-          return
+          logger.error "Unrecognized name '#{name}': names must start with " \
+            "either 'perform_job' (for jobs and tasks) or 'process_action' " \
+            "(for HTTP requests)"
+          return yield
         end
+
+        return yield unless active?
+
         transaction = Appsignal::Transaction.create(
           SecureRandom.uuid,
           namespace,

data/lib/appsignal/hooks.rb

@@ -37,7 +37,9 @@ module Appsignal
           install
           @installed = true
         rescue => ex
-          Appsignal.logger.error("Error while installing #{name} hook: #{ex}")
+          logger = Appsignal.logger
+          logger.error("Error while installing #{name} hook: #{ex}")
+          logger.debug ex.backtrace.join("\n")
         end
       end
 

data/lib/appsignal/hooks/active_support_notifications.rb

@@ -30,16 +30,13 @@ module Appsignal
             # Events that start with a bang are internal to Rails
             instrument_this = name[0] != BANG
 
-            if instrument_this
-              transaction = Appsignal::Transaction.current
-              transaction.start_event
-            end
+            Appsignal::Transaction.current.start_event if instrument_this
 
             instrument_without_appsignal(name, payload, &block)
           ensure
             if instrument_this
               title, body, body_format = Appsignal::EventFormatter.format(name, payload)
-              transaction.finish_event(
+              Appsignal::Transaction.current.finish_event(
                 name.to_s,
                 title,
                 body,

data/lib/appsignal/hooks/sidekiq.rb

@@ -26,7 +26,7 @@ module Appsignal
       attr_reader :config
 
       def self.dependencies_present?
-        Gem::Version.new(Redis::VERSION) >= Gem::Version.new("3.3.5")
+        Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("3.3.5")
       end
 
       def initialize(config = {})

data/lib/appsignal/minutely.rb

@@ -176,20 +176,28 @@ module Appsignal
 
       def initialize_probes
         probes.each do |name, probe|
-          if probe.respond_to? :new
-            instance = probe.new
-            klass = probe
-          else
-            instance = probe
-            klass = instance.class
-          end
-          unless dependencies_present?(klass)
-            Appsignal.logger.debug "Skipping '#{name}' probe, " \
-              "#{klass}.dependency_present? returned falsy"
-            next
-          end
-          probe_instances[name] = instance
+          initialize_probe(name, probe)
+        end
+      end
+
+      def initialize_probe(name, probe)
+        if probe.respond_to? :new
+          instance = probe.new
+          klass = probe
+        else
+          instance = probe
+          klass = instance.class
+        end
+        unless dependencies_present?(klass)
+          Appsignal.logger.debug "Skipping '#{name}' probe, " \
+            "#{klass}.dependency_present? returned falsy"
+          return
         end
+        probe_instances[name] = instance
+      rescue => error
+        logger = Appsignal.logger
+        logger.error "Error while initializing minutely probe '#{name}': #{error}"
+        logger.debug error.backtrace.join("\n")
       end
 
       def dependencies_present?(probe)

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.9.8".freeze
+  VERSION = "2.9.9".freeze
 end

data/spec/lib/appsignal/cli/notify_of_deploy_spec.rb

@@ -116,6 +116,9 @@ describe Appsignal::CLI::NotifyOfDeploy do
 
       context "with required options" do
         let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs" } }
+        let(:log_stream) { std_stream }
+        let(:log) { log_contents(log_stream) }
+        before { Appsignal.logger = test_logger(log_stream) }
 
         it "notifies of a deploy" do
           run
@@ -124,6 +127,13 @@ describe Appsignal::CLI::NotifyOfDeploy do
           expect(output).to include_deploy_notification_with(options)
         end
 
+        it "prints a deprecation message" do
+          run
+          deprecation_message = "This command (appsignal notify_of_deploy) has been deprecated"
+          expect(output).to include("appsignal WARNING: #{deprecation_message}")
+          expect(log).to contains_log :warn, deprecation_message
+        end
+
         context "with no app name configured" do
           before { ENV["APPSIGNAL_APP_NAME"] = "" }
 

data/spec/lib/appsignal/hooks/active_support_notifications_spec.rb

@@ -2,12 +2,14 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
   if active_support_present?
     let(:notifier) { ActiveSupport::Notifications::Fanout.new }
     let(:as) { ActiveSupport::Notifications }
+    let!(:transaction) do
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+    end
     before :context do
       start_agent
     end
     before do
       as.notifier = notifier
-      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
     end
 
     describe "#dependencies_present?" do
@@ -17,41 +19,71 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
     end
 
     it "instruments an ActiveSupport::Notifications.instrument event" do
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("sql.active_record", nil, "SQL", 1)
-
       return_value = as.instrument("sql.active_record", :sql => "SQL") do
         "value"
       end
 
       expect(return_value).to eq "value"
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "SQL",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "sql.active_record",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
     end
 
     it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("no-registered.formatter", nil, nil, nil)
-
       return_value = as.instrument("no-registered.formatter", :key => "something") do
         "value"
       end
 
       expect(return_value).to eq "value"
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "no-registered.formatter",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
     end
 
-    it "should convert non-string names to strings" do
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("not_a_string", nil, nil, nil)
-
+    it "converts non-string names to strings" do
       as.instrument(:not_a_string) {}
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "not_a_string",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
     end
 
     it "does not instrument events whose name starts with a bang" do
@@ -67,33 +99,66 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
 
     context "when an error is raised in an instrumented block" do
       it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect(Appsignal::Transaction.current).to receive(:start_event)
-          .at_least(:once)
-        expect(Appsignal::Transaction.current).to receive(:finish_event)
-          .at_least(:once)
-          .with("sql.active_record", nil, "SQL", 1)
-
         expect do
           as.instrument("sql.active_record", :sql => "SQL") do
             raise ExampleException, "foo"
           end
         end.to raise_error(ExampleException, "foo")
+
+        expect(transaction.to_h["events"]).to match([
+          {
+            "allocation_count" => kind_of(Integer),
+            "body" => "SQL",
+            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+            "child_allocation_count" => kind_of(Integer),
+            "child_duration" => kind_of(Float),
+            "child_gc_duration" => kind_of(Float),
+            "count" => 1,
+            "duration" => kind_of(Float),
+            "gc_duration" => kind_of(Float),
+            "name" => "sql.active_record",
+            "start" => kind_of(Float),
+            "title" => ""
+          }
+        ])
       end
     end
 
     context "when a message is thrown in an instrumented block" do
       it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect(Appsignal::Transaction.current).to receive(:start_event)
-          .at_least(:once)
-        expect(Appsignal::Transaction.current).to receive(:finish_event)
-          .at_least(:once)
-          .with("sql.active_record", nil, "SQL", 1)
-
         expect do
           as.instrument("sql.active_record", :sql => "SQL") do
             throw :foo
           end
         end.to throw_symbol(:foo)
+
+        expect(transaction.to_h["events"]).to match([
+          {
+            "allocation_count" => kind_of(Integer),
+            "body" => "SQL",
+            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+            "child_allocation_count" => kind_of(Integer),
+            "child_duration" => kind_of(Float),
+            "child_gc_duration" => kind_of(Float),
+            "count" => 1,
+            "duration" => kind_of(Float),
+            "gc_duration" => kind_of(Float),
+            "name" => "sql.active_record",
+            "start" => kind_of(Float),
+            "title" => ""
+          }
+        ])
+      end
+    end
+
+    context "when a transaction is completed in an instrumented block" do
+      it "does not complete the ActiveSupport::Notifications.instrument event" do
+        expect(transaction).to receive(:complete)
+        as.instrument("sql.active_record", :sql => "SQL") do
+          Appsignal::Transaction.complete_current!
+        end
+
+        expect(transaction.to_h["events"]).to match([])
       end
     end
   else

data/spec/lib/appsignal/hooks_spec.rb

@@ -68,6 +68,10 @@ describe Appsignal::Hooks do
     expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
 
     expect(Appsignal.logger).to receive(:error).with("Error while installing mock_error_hook hook: error").once
+    expect(Appsignal.logger).to receive(:debug).once do |message|
+      # Start of the error backtrace as debug log
+      expect(message).to start_with(File.expand_path("../../../../", __FILE__))
+    end
 
     Appsignal::Hooks.load_hooks
 

data/spec/lib/appsignal/minutely_spec.rb

@@ -38,6 +38,17 @@ describe Appsignal::Minutely do
       end
     end
 
+    class BrokenProbeOnInitialize < Probe
+      def initialize
+        super
+        raise "oh no initialize!"
+      end
+
+      def call
+        true
+      end
+    end
+
     let(:log_stream) { StringIO.new }
     let(:log) { log_contents(log_stream) }
     before do
@@ -109,12 +120,38 @@ describe Appsignal::Minutely do
             "ProbeWithMissingDependency.dependency_present? returned falsy"
         end
       end
+
+      context "when there is a problem initializing the probe" do
+        it "logs an error" do
+          # Working probe which we can use to wait for X ticks
+          working_probe = ProbeWithoutDependency
+          working_probe_instance = working_probe.new
+          expect(working_probe).to receive(:new).and_return(working_probe_instance)
+          Appsignal::Minutely.probes.register :probe_without_dep, working_probe
+
+          probe = BrokenProbeOnInitialize
+          Appsignal::Minutely.probes.register :broken_probe_on_initialize, probe
+          Appsignal::Minutely.start
+
+          wait_for("enough probe calls") { working_probe_instance.calls >= 2 }
+          # Only counts initialized probes
+          expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
+          # Logs error
+          expect(log).to contains_log(
+            :error,
+            "Error while initializing minutely probe 'broken_probe_on_initialize': " \
+              "oh no initialize!"
+          )
+          # Start of the error backtrace as debug log
+          expect(log).to contains_log :debug, File.expand_path("../../../../", __FILE__)
+        end
+      end
     end
 
     context "with a lambda" do
       it "calls the lambda every <wait time>" do
         calls = 0
-        probe = -> { calls += 1 }
+        probe = lambda { calls += 1 }
         Appsignal::Minutely.probes.register :my_probe, probe
         Appsignal::Minutely.start
 
@@ -184,7 +221,7 @@ describe Appsignal::Minutely do
     end
 
     it "clears the probe instances array" do
-      Appsignal::Minutely.probes.register :my_probe, -> {}
+      Appsignal::Minutely.probes.register :my_probe, lambda {}
       Appsignal::Minutely.start
       thread = Appsignal::Minutely.class_variable_get(:@@thread)
       wait_for("probes initialized") do
@@ -232,17 +269,17 @@ describe Appsignal::Minutely do
     describe "#count" do
       it "returns how many probes are registered" do
         expect(collection.count).to eql(0)
-        collection.register :my_probe_1, -> {}
+        collection.register :my_probe_1, lambda {}
         expect(collection.count).to eql(1)
-        collection.register :my_probe_2, -> {}
+        collection.register :my_probe_2, lambda {}
         expect(collection.count).to eql(2)
       end
     end
 
     describe "#clear" do
       it "clears the list of probes" do
-        collection.register :my_probe_1, -> {}
-        collection.register :my_probe_2, -> {}
+        collection.register :my_probe_1, lambda {}
+        collection.register :my_probe_2, lambda {}
         expect(collection.count).to eql(2)
         collection.clear
         expect(collection.count).to eql(0)
@@ -251,7 +288,7 @@ describe Appsignal::Minutely do
 
     describe "#[]" do
       it "returns the probe for that name" do
-        probe = -> {}
+        probe = lambda {}
         collection.register :my_probe, probe
         expect(collection[:my_probe]).to eql(probe)
       end
@@ -265,7 +302,7 @@ describe Appsignal::Minutely do
       before { Appsignal.logger = test_logger(log_stream) }
 
       it "adds the probe, but prints a deprecation warning" do
-        probe = -> {}
+        probe = lambda {}
         capture_stdout(out_stream) { collection << probe }
         deprecation_message = "Deprecated " \
           "`Appsignal::Minute.probes <<` call. Please use " \
@@ -282,14 +319,14 @@ describe Appsignal::Minutely do
       before { Appsignal.logger = test_logger(log_stream) }
 
       it "adds the by key probe" do
-        probe = -> {}
+        probe = lambda {}
         collection.register :my_probe, probe
         expect(collection[:my_probe]).to eql(probe)
       end
 
       context "when a probe is already registered with the same key" do
         it "logs a debug message" do
-          probe = -> {}
+          probe = lambda {}
           collection.register :my_probe, probe
           collection.register :my_probe, probe
           expect(log).to contains_log :debug, "A probe with the name " \
@@ -302,7 +339,7 @@ describe Appsignal::Minutely do
 
     describe "#each" do
       it "loops over the registered probes" do
-        probe = -> {}
+        probe = lambda {}
         collection.register :my_probe, probe
         list = []
         collection.each do |name, p|

data/spec/lib/appsignal_spec.rb

@@ -240,6 +240,16 @@ describe Appsignal do
 
   context "not active" do
     describe ".monitor_transaction" do
+      let(:log_stream) { StringIO.new }
+      let(:log) { log_contents(log_stream) }
+      before do
+        Appsignal.config = project_fixture_config("not_active")
+        Appsignal.start
+        Appsignal.start_logger
+        Appsignal.logger = test_logger(log_stream)
+      end
+      after { Appsignal.logger = nil }
+
       it "should do nothing but still yield the block" do
         expect(Appsignal::Transaction).to_not receive(:create)
         expect(Appsignal).to_not receive(:instrument)
@@ -252,6 +262,23 @@ describe Appsignal do
           end).to eq 1
         end.to_not raise_error
       end
+
+      context "with an unknown event type" do
+        it "yields the given block" do
+          expect do |blk|
+            Appsignal.monitor_transaction("unknown.sidekiq", &blk)
+          end.to yield_control
+        end
+
+        it "logs an error" do
+          Appsignal.monitor_transaction("unknown.sidekiq") {}
+          expect(log).to contains_log(
+            :error,
+            "Unrecognized name 'unknown.sidekiq': names must start with either 'perform_job' " \
+              "(for jobs and tasks) or 'process_action' (for HTTP requests)"
+          )
+        end
+      end
     end
 
     describe ".listen_for_error" do
@@ -299,10 +326,15 @@ describe Appsignal do
   end
 
   context "with config and started" do
+    let(:log_stream) { StringIO.new }
+    let(:log) { log_contents(log_stream) }
     before do
       Appsignal.config = project_fixture_config
       Appsignal.start
+      Appsignal.start_logger
+      Appsignal.logger = test_logger(log_stream)
     end
+    after { Appsignal.logger = nil }
 
     describe ".monitor_transaction" do
       context "with a successful call" do
@@ -359,6 +391,23 @@ describe Appsignal do
           end.to raise_error(error)
         end
       end
+
+      context "with an unknown event type" do
+        it "yields the given block" do
+          expect do |blk|
+            Appsignal.monitor_transaction("unknown.sidekiq", &blk)
+          end.to yield_control
+        end
+
+        it "logs an error" do
+          Appsignal.monitor_transaction("unknown.sidekiq") {}
+          expect(log).to contains_log(
+            :error,
+            "Unrecognized name 'unknown.sidekiq': names must start with either 'perform_job' " \
+              "(for jobs and tasks) or 'process_action' (for HTTP requests)"
+          )
+        end
+      end
     end
 
     describe ".monitor_single_transaction" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 2.9.8
+  version: 2.9.9
 platform: ruby
 authors:
 - Robert Beekman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-03 00:00:00.000000000 Z
+date: 2019-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -132,6 +132,8 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/chore.md"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"