flapjack 0.7.20 → 0.7.21

data/spec/lib/flapjack/data/contact_spec.rb

@@ -6,11 +6,12 @@ require 'ice_cube'
 require 'flapjack/data/contact'
 require 'flapjack/data/entity_check'
 require 'flapjack/data/notification_rule'
+require 'flapjack/data/tag_set'
 
 describe Flapjack::Data::Contact, :redis => true do
 
   let(:notification_rule_data) {
-    {:entity_tags        => ["database","physical"],
+    {:tags               => ["database","physical"],
      :entities           => ["foo-app-01.example.com"],
      :time_restrictions  => [],
      :warning_media      => ["email"],
@@ -22,7 +23,7 @@ describe Flapjack::Data::Contact, :redis => true do
 
   let(:general_notification_rule_data) {
     {:entities           => [],
-     :entity_tags        => [],
+     :tags               => Flapjack::Data::TagSet.new([]),
      :time_restrictions  => [],
      :warning_media      => ['email', 'sms', 'jabber', 'pagerduty'],
      :critical_media     => ['email', 'sms', 'jabber', 'pagerduty'],
@@ -156,7 +157,7 @@ describe Flapjack::Data::Contact, :redis => true do
     rules = contact.notification_rules
     rules.should have(1).rule
     rule = rules.first
-    [:entities, :entity_tags, :time_restrictions,
+    [:entities, :tags, :time_restrictions,
      :warning_media, :critical_media,
      :warning_blackhole, :critical_blackhole].each do |k|
       rule.send(k).should == general_notification_rule_data[k]

data/spec/lib/flapjack/data/entity_check_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 require 'flapjack/data/entity'
 require 'flapjack/data/entity_check'
+require 'flapjack/data/tag_set'
 
 describe Flapjack::Data::EntityCheck, :redis => true do
 
@@ -574,4 +575,13 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     contacts.should have(1).contact
     contacts.first.name.should == 'John Johnson'
   end
+
+  it "generates ephemeral tags for itself" do
+    ec = Flapjack::Data::EntityCheck.for_entity_name('foo-app-01.example.com', 'Disk / Utilisation', :redis => @redis)
+    tags = ec.tags
+    tags.should_not be_nil
+    tags.should be_a(Flapjack::Data::TagSet)
+    ['foo-app-01', 'example.com', 'disk', '/', 'utilisation'].to_set.subset?(tags).should be_true
+  end
+
 end

data/spec/lib/flapjack/data/entity_spec.rb

@@ -176,16 +176,71 @@ describe Flapjack::Data::Entity, :redis => true do
   end
 
   it "finds entities by tag" do
-    entity = Flapjack::Data::Entity.add({'id'       => '5000',
+    entity0 = Flapjack::Data::Entity.add({'id'       => '5000',
+                                          'name'     => 'abc-123',
+                                          'contacts' => []},
+                                         :redis => @redis)
+
+    entity1 = Flapjack::Data::Entity.add({'id'       => '5001',
+                                          'name'     => 'def-456',
+                                          'contacts' => []},
+                                         :redis => @redis)
+
+    entity0.add_tags('source:foobar', 'abc')
+    entity1.add_tags('source:foobar', 'def')
+
+    entity0.should_not be_nil
+    entity0.should be_an(Flapjack::Data::Entity)
+    entity0.tags.should include("source:foobar")
+    entity0.tags.should include("abc")
+    entity0.tags.should_not include("def")
+    entity1.should_not be_nil
+    entity1.should be_an(Flapjack::Data::Entity)
+    entity1.tags.should include("source:foobar")
+    entity1.tags.should include("def")
+    entity1.tags.should_not include("abc")
+
+    entities = Flapjack::Data::Entity.find_all_with_tags(['abc'], :redis => @redis)
+    entities.should be_an(Array)
+    entities.should have(1).entity
+    entities.first.should == 'abc-123'
+
+    entities = Flapjack::Data::Entity.find_all_with_tags(['donkey'], :redis => @redis)
+    entities.should be_an(Array)
+    entities.should have(0).entities
+  end
+
+  it "finds entities with several tags" do
+    entity0 = Flapjack::Data::Entity.add({'id'       => '5000',
                                          'name'     => 'abc-123',
                                          'contacts' => []},
                                         :redis => @redis)
 
-    entity.add_tags('source:foobar', 'foo')
+    entity1 = Flapjack::Data::Entity.add({'id'       => '5001',
+                                         'name'     => 'def-456',
+                                         'contacts' => []},
+                                        :redis => @redis)
 
-    entity.should_not be_nil
-    entity.should be_an(Flapjack::Data::Entity)
-    # TODO - the rest of it
+    entity0.add_tags('source:foobar', 'abc')
+    entity1.add_tags('source:foobar', 'def')
+
+    entity0.should_not be_nil
+    entity0.should be_an(Flapjack::Data::Entity)
+    entity0.tags.should include("source:foobar")
+    entity0.tags.should include("abc")
+    entity1.should_not be_nil
+    entity1.should be_an(Flapjack::Data::Entity)
+    entity1.tags.should include("source:foobar")
+    entity1.tags.should include("def")
+
+    entities = Flapjack::Data::Entity.find_all_with_tags(['source:foobar'], :redis => @redis)
+    entities.should be_an(Array)
+    entities.should have(2).entity
+
+    entities = Flapjack::Data::Entity.find_all_with_tags(['source:foobar', 'def'], :redis => @redis)
+    entities.should be_an(Array)
+    entities.should have(1).entity
+    entities.first.should == 'def-456'
   end
 
 end

data/spec/lib/flapjack/data/event_spec.rb

@@ -58,13 +58,13 @@ describe Flapjack::Data::Event do
       events_len = 23
       mock_redis.should_receive(:llen).with('events').and_return(events_len)
 
-      pc = Flapjack::Data::Event.pending_count(:redis => mock_redis)
+      pc = Flapjack::Data::Event.pending_count('events', :redis => mock_redis)
       pc.should == events_len
     end
 
     it "creates a notification testing event" do
       Time.should_receive(:now).and_return(time)
-      mock_redis.should_receive(:rpush).with('events', /"testing"/ )
+      mock_redis.should_receive(:lpush).with('events', /"testing"/ )
 
       Flapjack::Data::Event.test_notifications(entity_name, check,
         :summary => 'test', :details => 'testing', :redis => mock_redis)
@@ -72,7 +72,7 @@ describe Flapjack::Data::Event do
 
     it "creates an acknowledgement event" do
       Time.should_receive(:now).and_return(time)
-      mock_redis.should_receive(:rpush).with('events', /"acking"/ )
+      mock_redis.should_receive(:lpush).with('events', /"acking"/ )
 
       Flapjack::Data::Event.create_acknowledgement(entity_name, check,
         :summary => 'acking', :time => time.to_i, :redis => mock_redis)
@@ -98,4 +98,4 @@ describe Flapjack::Data::Event do
     it { should be_a_failure }
   end
 
-end
+end

data/spec/lib/flapjack/data/notification_rule_spec.rb

@@ -14,7 +14,7 @@ describe Flapjack::Data::NotificationRule, :redis => true do
 
   let(:rule_data) {
     {:contact_id         => '23',
-     :entity_tags        => ["database","physical"],
+     :tags               => ["database","physical"],
      :entities           => ["foo-app-01.example.com"],
      :time_restrictions  => [ weekdays_8_18 ],
      :warning_media      => ["email"],
@@ -76,7 +76,14 @@ describe Flapjack::Data::NotificationRule, :redis => true do
     rule.match_entity?('foo-app-02.example.com').should be_false
   end
 
-  pending "check whether entity tags match"
+  it "checks whether entity tags match" do
+    rule = existing_rule
+
+    rule.match_tags?(['database', 'physical'].to_set).should be_true
+    rule.match_tags?(['database', 'physical', 'beetroot'].to_set).should be_true
+    rule.match_tags?(['database'].to_set).should be_false
+    rule.match_tags?(['virtual'].to_set).should be_false
+  end
 
   it "checks if blackhole settings for a rule match a severity level" do
     rule_data[:warning_blackhole] = true

data/spec/lib/flapjack/data/tag_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'flapjack/data/entity'
 
 describe Flapjack::Data::Tag, :redis => true do
 

data/spec/lib/flapjack/gateways/api/contact_methods_spec.rb

@@ -37,7 +37,7 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
 
   let(:notification_rule_data) {
     {"contact_id"         => "21",
-     "entity_tags"        => ["database","physical"],
+     "tags"               => ["database","physical"],
      "entities"           => ["foo-app-01.example.com"],
      "time_restrictions"  => nil,
      "warning_media"      => ["email"],

data/spec/lib/flapjack/gateways/email_spec.rb

@@ -15,6 +15,7 @@ describe Flapjack::Gateways::Email, :logger => true do
     entity_check = mock(Flapjack::Data::EntityCheck)
     entity_check.should_receive(:in_scheduled_maintenance?).and_return(false)
     entity_check.should_receive(:in_unscheduled_maintenance?).and_return(false)
+    entity_check.should_receive(:last_change).and_return(Time.now.to_i)
 
     redis = mock('redis')
     ::Resque.should_receive(:redis).and_return(redis)
@@ -46,4 +47,4 @@ describe Flapjack::Gateways::Email, :logger => true do
     Flapjack::Gateways::Email.perform(notification)
   end
 
-end
+end

data/spec/lib/flapjack/gateways/jabber_spec.rb

@@ -151,9 +151,11 @@ describe Flapjack::Gateways::Jabber, :logger => true do
   end
 
   it "prompts the blocking redis connection to quit" do
-    redis = mock('redis')
-    redis.should_receive(:rpush).with('jabber_notifications', %q{{"notification_type":"shutdown"}})
+    shutdown_redis = mock('shutdown_redis')
+    shutdown_redis.should_receive(:rpush).with('jabber_notifications', %q{{"notification_type":"shutdown"}})
+    EM::Hiredis.should_receive(:connect).and_return(shutdown_redis)
 
+    redis = mock('redis')
     Flapjack::RedisPool.should_receive(:new).and_return(redis)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
@@ -163,7 +165,7 @@ describe Flapjack::Gateways::Jabber, :logger => true do
   it "runs a blocking loop listening for notifications" do
     timer = mock('timer')
     timer.should_receive(:cancel)
-    EM::Synchrony.should_receive(:add_periodic_timer).with(60).and_return(timer)
+    EM::Synchrony.should_receive(:add_periodic_timer).with(1).and_return(timer)
 
     redis = mock('redis')
 

data/spec/lib/flapjack/gateways/pagerduty_spec.rb

@@ -11,7 +11,9 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
   let(:redis) {  mock('redis') }
 
   it "prompts the blocking redis connection to quit" do
-    redis.should_receive(:rpush).with(config['queue'], %q{{"notification_type":"shutdown"}})
+    shutdown_redis = mock('shutdown_redis')
+    shutdown_redis.should_receive(:rpush).with(config['queue'], %q{{"notification_type":"shutdown"}})
+    EM::Hiredis.should_receive(:connect).and_return(shutdown_redis)
 
     Flapjack::RedisPool.should_receive(:new).and_return(redis)
     fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)

data/spec/lib/flapjack/logger_spec.rb

@@ -10,21 +10,21 @@ describe Flapjack::Logger do
   it "creates a logger logging to STDOUT and syslog" do
     logger.should_receive(:formatter=).with(an_instance_of(Proc))
     logger.should_receive(:level=).and_return(Logger::DEBUG)
-    logger.should_receive(:warn).with("Yowza!")
+    logger.should_receive(:add).with(2, nil, "Yowza!")
     ::Logger.should_receive(:new).with(STDOUT).and_return(logger)
 
     if Syslog.const_defined?('Logger', false)
       sys_logger.should_receive(:formatter=).with(an_instance_of(Proc))
       sys_logger.should_receive(:level=).with(Logger::DEBUG)
-      sys_logger.should_receive(:warn).with("Yowza!")
+      sys_logger.should_receive(:add).with(Logger::WARN, 'Yowza!', 'flapjack')
       Syslog.const_get('Logger', false).should_receive(:new).with('flapjack').and_return(sys_logger)
     else
-      syslog.should_receive(:log).with(Syslog::Constants::LOG_WARNING, /\[WARN\] :: spec :: %s/, "Yowza!")
-      Syslog.should_receive(:"opened?").and_return(false)
       Syslog.should_receive(:open).with('flapjack',
         (Syslog::Constants::LOG_PID | Syslog::Constants::LOG_CONS),
          Syslog::Constants::LOG_USER).and_return(syslog)
-      Syslog.should_receive(:mask=).with(Syslog::LOG_UPTO(Syslog::Constants::LOG_DEBUG))
+      Syslog.should_receive(:mask=).with(Syslog::LOG_UPTO(Syslog::Constants::LOG_WARNING))
+      Syslog.should_receive(:log).with(Syslog::Constants::LOG_WARNING, /\[WARN\] :: spec :: %s/, "Yowza!")
+      Syslog.should_receive(:close)
     end
 
     flogger = Flapjack::Logger.new('spec', 'level' => 'debug')

data/spec/lib/flapjack/pikelet_spec.rb

@@ -21,17 +21,19 @@ describe Flapjack::Pikelet do
 
     config.should_receive(:[]).with('logger').and_return(nil)
 
+    fc = mock('coordinator')
+
     processor = mock('processor')
     processor.should_receive(:start)
     Flapjack::Processor.should_receive(:new).with(:config => config,
-        :redis_config => redis_config, :boot_time => time, :logger => logger).
+        :redis_config => redis_config, :boot_time => time, :logger => logger, :coordinator => fc).
       and_return(processor)
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
     pik = Flapjack::Pikelet.create('processor', :config => config,
-      :redis_config => redis_config, :boot_time => time)
+      :redis_config => redis_config, :boot_time => time, :coordinator => fc)
     pik.should be_a(Flapjack::Pikelet::Generic)
     pik.start
   end

data/spec/lib/flapjack/processor_spec.rb

@@ -1,11 +1,14 @@
 require 'spec_helper'
 require 'flapjack/processor'
+require 'flapjack/coordinator'
 
 describe Flapjack::Processor, :logger => true do
 
   # NB: this is only testing the public API of the Processor class, which is pretty limited.
   # (initialize, main, stop). Most test coverage for this class comes from the cucumber features.
 
+  let(:config) { mock(Flapjack::Configuration) }
+
   # TODO this does too much -- split it up
   it "starts up, runs and shuts down" do
     t = Time.now.to_i
@@ -37,20 +40,26 @@ describe Flapjack::Processor, :logger => true do
     # redis.should_receive(:hincrby).with('event_counters', 'all', 1)
     # redis.should_receive(:hincrby).with(/^event_counters:/, 'all', 1)
 
-    Flapjack::Data::Event.should_receive(:pending_count).with(:redis => redis).and_return(0)
+    Flapjack::Data::Event.should_receive(:pending_count).with('events', :redis => redis).and_return(0)
 
     Flapjack::RedisPool.should_receive(:new).and_return(redis)
-    executive = Flapjack::Processor.new(:config => {}, :logger => @logger)
 
-    shutdown_evt = mock(Flapjack::Data::Event)
-    shutdown_evt.should_receive(:inspect)
-    shutdown_evt.should_receive(:type).and_return('shutdown')
+    fc = mock('coordinator')
+
+    executive = Flapjack::Processor.new(:config => {}, :logger => @logger, :coordinator => fc)
+
+    noop_evt = mock(Flapjack::Data::Event)
+    noop_evt.should_receive(:inspect)
+    noop_evt.should_receive(:type).and_return('noop')
     Flapjack::Data::Event.should_receive(:next) {
       executive.instance_variable_set('@should_quit', true)
-      shutdown_evt
+      noop_evt
     }
 
-    executive.start
+    begin
+      executive.start
+    rescue SystemExit
+    end
   end
 
 end

data/tasks/benchmarks.rake

@@ -0,0 +1,228 @@
+require 'redis'
+require 'oj'
+require 'time'
+
+namespace :benchmarks do
+
+  # add lib to the default include path
+  unless $:.include?(File.dirname(__FILE__) + '/../lib/')
+    $: << File.dirname(__FILE__) + '/../lib'
+  end
+
+  require 'flapjack/configuration'
+  require 'flapjack/data/event'
+  require 'flapjack/data/entity_check'
+  require 'flapjack/version'
+
+  FLAPJACK_ENV = ENV['FLAPJACK_ENV'] || 'test'
+  config_file = File.join('tasks', 'support', 'flapjack_config_benchmark.yaml')
+
+  config = Flapjack::Configuration.new
+  config.load( config_file )
+
+  @config_env = config.all
+  @redis_config = config.for_redis
+
+  if @config_env.nil? || @config_env.empty?
+    puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{config_file}'"
+    exit(false)
+  end
+
+  redis = Redis.new(@redis_config)
+
+  desc "nukes the redis db, generates the events, runs and shuts down flapjack, generates perftools reports"
+  task :run => [:reset_redis, :benchmark, :run_flapjack, :reports] do
+    puts Oj.dump(@benchmark_data, :indent => 2)
+  end
+
+  desc "reset the redis database"
+  task :reset_redis do
+    raise "I'm not going to let you reset your production redis db, sorry about that." if FLAPJACK_ENV.downcase == "production"
+    puts "db size before: #{redis.dbsize}"
+    redis.flushdb
+    puts "db size after: #{redis.dbsize}"
+  end
+
+  desc "starts flapjack"
+  task :run_flapjack do
+    puts "Discovering path to perftools"
+    perftools = `gem which perftools | tail -1`
+    if system("if [ ! -d 'artifacts' ] ; then mkdir artifacts ; fi")
+      puts "we now have an artifacts dir"
+    else
+      raise "Problem creating artifacts: #{$?}"
+    end
+    time_flapjack_start = Time.now.to_f
+    puts "Starting flapjack..."
+    if system({"FLAPJACK_ENV" => FLAPJACK_ENV,
+               "CPUPROFILE"   => "artifacts/flapjack-perftools-cpuprofile",
+               "RUBYOPT"      => "-r#{perftools}"},
+              "bin/flapjack start --no-daemonize --config tasks/support/flapjack_config_benchmark.yaml")
+      puts "Flapjack run completed successfully"
+    else
+      raise "Problem starting flapjack: #{$?}"
+    end
+    @timer_flapjack = Time.now.to_f - time_flapjack_start
+  end
+
+  desc "generates perftools reports"
+  task :reports do
+    @benchmark_data = { 'events_created'   => @events_created,
+                        'flapjack_runtime' => @timer_flapjack,
+                        'processing_rate'  => @events_created.to_f / @timer_flapjack }.merge(@benchmark_parameters)
+    bytes_written = IO.write('artifacts/benchmark_data.json', Oj.dump(@benchmark_data, :indent => 2))
+    puts "benchmark data written to artifacts/benchmark_data.json (#{bytes_written} bytes)"
+
+    if system("pprof.rb --text artifacts/flapjack-perftools-cpuprofile > artifacts/flapjack-perftools-cpuprofile.txt")
+      puts "Generated perftools.rb text report at artifacts/flapjack-perftools-cpuprofile.txt"
+      system("head -24 artifacts/flapjack-perftools-cpuprofile.txt")
+    else
+      raise "Problem generating perftools.rb text report: #{$?}"
+    end
+    if system("pprof.rb --pdf artifacts/flapjack-perftools-cpuprofile > artifacts/flapjack-perftools-cpuprofile.pdf")
+      puts "Generated perftools.rb pdf report at artifacts/flapjack-perftools-cpuprofile.pdf"
+    else
+      raise "Problem generating perftools.rb pdf report: #{$?}"
+    end
+  end
+
+
+  desc "run benchmark - simulate a stream of events from the check execution system"
+  # Assumptions:
+  # - time to failure varies evenly between 1 hour and 1 month
+  # - time to recovery varies evenly between 10 seconds and 1 week
+  task :benchmark do
+
+    num_checks_per_entity = (ENV['CHECKS_PER_ENTITY'] || 5).to_i
+    num_entities          = (ENV['ENTITIES'] || 100).to_i
+    interval              = (ENV['INTERVAL'] || 60).to_i
+    hours                 = (ENV['HOURS'] || 1).to_f
+    seed                  = (ENV['SEED'] || 42).to_i
+
+    puts "Behaviour can be modified by setting any combination of the following environment variables: "
+    puts "CHECKS_PER_ENTITY - #{num_checks_per_entity}"
+    puts "ENTITIES          - #{num_entities}"
+    puts "INTERVAL          - #{interval}"
+    puts "HOURS             - #{hours}"
+    puts "SEED              - #{seed}"
+    puts "FLAPJACK_ENV      - #{FLAPJACK_ENV}"
+
+    raise "INTERVAL must be less than (or equal to) 3600 seconds (1 hour)" unless interval <= 3600
+
+    cycles_per_hour   = (60.0 * 60) / interval
+    cycles_per_day    = (60.0 * 60 * 24) / interval
+    cycles_per_week   = (60.0 * 60 * 24 * 7) / interval
+    cycles_per_month  = (60.0 * 60 * 24 * 7 * 30) / interval
+    cycles            = (hours * cycles_per_hour).to_i
+    failure_prob_min  = 1.0 / cycles_per_month
+    failure_prob_max  = 1.0 / cycles_per_hour
+    recovery_prob_min = 1.0 / cycles_per_week
+    recovery_prob_max = 1.0
+    initial_ok_prob   = 1
+    num_checks = num_checks_per_entity * num_entities
+
+    prng = Random.new(seed)
+
+    ok = 0
+    critical = 0
+    check_id = 1
+    entities = (1..num_entities).to_a.inject({}) {|memo, id|
+      checks = (1..num_checks_per_entity).to_a.inject({}) {|memo_check, id_check|
+        memo_check[check_id] = {:name => "Check Type #{id_check}",
+                                :state => ( prng.rand < initial_ok_prob ? 'OK' : 'CRITICAL' ),
+                                :p_failure => prng.rand(failure_prob_min..failure_prob_max),
+                                :p_recovery => prng.rand(recovery_prob_min..recovery_prob_max)}
+        ok       += 1 if memo_check[check_id][:state] == 'OK'
+        critical += 1 if memo_check[check_id][:state] == 'CRITICAL'
+        check_id += 1
+        memo_check
+      }
+      memo[id] = checks
+      memo
+    }
+    #puts "ok: #{ok * 100.0 / num_checks}% (#{ok}), critical: #{100.0 * critical / num_checks}% (#{critical})"
+
+    events_created  = 0
+    ok_to_critical  = 0
+    critical_to_ok  = 0
+    ok_events       = 0
+    critical_events = 0
+    state_changes   = 0
+    (0..cycles).to_a.each {|i|
+      changes = 0
+      ok = 0
+      critical = 0
+      summary = "You tell me summer's here \nand the time is wrong \n"
+      summary << "You tell me winter's here \nAnd your days are getting long"
+      entities.each_pair {|entity_id, checks|
+        checks.each_pair {|check_id, check|
+          changed = false
+          previous_state = check[:state]
+          case previous_state
+          when "OK"
+            if prng.rand < check[:p_failure]
+              check[:state] = "CRITICAL"
+              changed = true
+              changes += 1
+              ok_to_critical += 1
+            end
+          when "CRITICAL"
+            if prng.rand < check[:p_recovery]
+              check[:state] = "OK"
+              changed = true
+              changes += 1
+              critical_to_ok += 1
+            end
+          end
+          ok       += 1 if check[:state] == 'OK'
+          critical += 1 if check[:state] == 'CRITICAL'
+
+          Flapjack::Data::Event.add({'entity'  => "entity_#{entity_id}.example.com",
+                                     'check'   => check[:name],
+                                     'type'    => 'service',
+                                     'state'   => check[:state],
+                                     'summary' => summary }, :redis => redis)
+          events_created += 1
+        }
+      }
+      ok_events       += ok
+      critical_events += critical
+      state_changes   += changes
+
+      #puts "ok: #{100.0 * ok / num_checks}% (#{ok}), critical: #{100.0 * critical / num_checks}% (#{critical}), changed: #{100.0 * changes / num_checks}% (#{changes})"
+
+    }
+    puts "created #{events_created} events:"
+    puts "  OK:             #{ok_events} (#{ (100.0 * ok_events / events_created).round(1)}%)"
+    puts "  CRITICAL:       #{critical_events} (#{ (100.0 * critical_events / events_created).round(1)}%)"
+    puts "containing #{state_changes} state changes (#{ (100.0 * state_changes / events_created).round(1)}%):"
+    puts "  OK -> CRITICAL: #{ok_to_critical} (#{ (100.0 * ok_to_critical / events_created).round(1)}%)"
+    puts "  CRITICAL -> OK: #{critical_to_ok} (#{ (100.0 * critical_to_ok / events_created).round(1)}%)"
+
+    @events_created = events_created
+    @benchmark_parameters = { 'events_created'    => events_created,
+                              'ok_to_critical'    => ok_to_critical,
+                              'critical_to_ok'    => critical_to_ok,
+                              'checks_per_entity' => num_checks_per_entity,
+                              'entities'          => num_entities,
+                              'interval'          => interval,
+                              'hours'             => hours,
+                              'cycles'            => cycles,
+                              'failure_prob_min'  => failure_prob_min,
+                              'failure_prob_max'  => failure_prob_max,
+                              'recovery_prob_min' => recovery_prob_min,
+                              'recovery_prob_max' => recovery_prob_max,
+                              'initial_ok_prob'   => initial_ok_prob,
+                              'seed'              => seed,
+                              'flapjack_env'      => FLAPJACK_ENV,
+                              'version'           => Flapjack::VERSION,
+                              'git_last_commit'   => `git rev-parse HEAD`.chomp,
+                              'git_version'       => `git describe --long --dirty --abbrev=10 --tags`.chomp,
+                              'git_branch'        => `git status --porcelain -b | head -1 | cut -d ' ' -f 2`.chomp,
+                              'ruby_build'        => `ruby --version`.chomp,
+                              'time'              => Time.new.iso8601,
+                              'hostname'          => `hostname -f`.chomp,
+                              'uname'             => `uname -a`.chomp }
+  end
+
+end