queue-bus 0.8.0 → 0.11.0

data/spec/matcher_spec.rb

@@ -1,143 +1,145 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Matcher do
-    it "should already return false on empty filters" do
+    it 'should already return false on empty filters' do
       matcher = Matcher.new({})
-      expect(matcher.matches?({})).to  eq(false)
+      expect(matcher.matches?({})).to eq(false)
       expect(matcher.matches?(nil)).to  eq(false)
-      expect(matcher.matches?("name" => "val")).to eq(false)
+      expect(matcher.matches?('name' => 'val')).to eq(false)
     end
 
-    it "should not crash if nil inputs" do
-      matcher = Matcher.new("name" => "val")
+    it 'should not crash if nil inputs' do
+      matcher = Matcher.new('name' => 'val')
       expect(matcher.matches?(nil)).to eq(false)
     end
 
-    it "string filter to/from redis" do
-      matcher = Matcher.new("name" => "val")
-      expect(matcher.matches?("name" => "val")).to   eq(true)
-      expect(matcher.matches?("name" => " val")).to  eq(false)
-      expect(matcher.matches?("name" => "zval")).to  eq(false)
+    it 'string filter to/from redis' do
+      matcher = Matcher.new('name' => 'val')
+      expect(matcher.matches?('name' => 'val')).to   eq(true)
+      expect(matcher.matches?('name' => ' val')).to  eq(false)
+      expect(matcher.matches?('name' => 'zval')).to  eq(false)
     end
 
-    it "regex filter" do
-      matcher = Matcher.new("name" => /^[cb]a+t/)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+    it 'regex filter' do
+      matcher = Matcher.new('name' => /^[cb]a+t/)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
     end
 
-    it "present filter" do
-      matcher = Matcher.new("name" => :present)
-      expect(matcher.matches?("name" => "")).to eq(false)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
+    it 'present filter' do
+      matcher = Matcher.new('name' => :present)
+      expect(matcher.matches?('name' => '')).to eq(false)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
     end
 
-    it "blank filter" do
-      matcher = Matcher.new("name" => :blank)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "   s ")).to eq(false)
+    it 'blank filter' do
+      matcher = Matcher.new('name' => :blank)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '   s ')).to eq(false)
     end
 
-    it "nil filter" do
-      matcher = Matcher.new("name" => :nil)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "")).to eq(false)
-      expect(matcher.matches?("name" => "  ")).to eq(false)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
+    it 'nil filter' do
+      matcher = Matcher.new('name' => :nil)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '')).to eq(false)
+      expect(matcher.matches?('name' => '  ')).to eq(false)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
     end
 
-    it "key filter" do
-      matcher = Matcher.new("name" => :key)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
+    it 'key filter' do
+      matcher = Matcher.new('name' => :key)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
     end
 
-    it "empty filter" do
-      matcher = Matcher.new("name" => :empty)
-      expect(matcher.matches?("name" => nil)).to eq(false)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(false)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "   s ")).to eq(false)
+    it 'empty filter' do
+      matcher = Matcher.new('name' => :empty)
+      expect(matcher.matches?('name' => nil)).to eq(false)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(false)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '   s ')).to eq(false)
     end
 
-    it "value filter" do
-      matcher = Matcher.new("name" => :value)
-      expect(matcher.matches?("name" => nil)).to eq(false)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "   s ")).to eq(true)
+    it 'value filter' do
+      matcher = Matcher.new('name' => :value)
+      expect(matcher.matches?('name' => nil)).to eq(false)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '   s ')).to eq(true)
     end
 
-    it "multiple filters" do
-      matcher = Matcher.new("name" => /^[cb]a+t/, "state" => "sleeping")
-      expect(matcher.matches?("state" => "sleeping", "name" => "cat")).to  eq(true)
-      expect(matcher.matches?("state" => "awake", "name" => "cat")).to     eq(false)
-      expect(matcher.matches?("state" => "sleeping", "name" => "bat")).to  eq(true)
-      expect(matcher.matches?("state" => "sleeping", "name" => "bear")).to eq(false)
-      expect(matcher.matches?("state" => "awake", "name" => "bear")).to    eq(false)
+    it 'multiple filters' do
+      matcher = Matcher.new('name' => /^[cb]a+t/, 'state' => 'sleeping')
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'cat')).to  eq(true)
+      expect(matcher.matches?('state' => 'awake', 'name' => 'cat')).to     eq(false)
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'bat')).to  eq(true)
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'bear')).to eq(false)
+      expect(matcher.matches?('state' => 'awake', 'name' => 'bear')).to    eq(false)
     end
 
-    it "regex should go back and forth into redis" do
-      matcher = Matcher.new("name" => /^[cb]a+t/)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+    it 'regex should go back and forth into redis' do
+      matcher = Matcher.new('name' => /^[cb]a+t/)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
 
-      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis = QueueBus.redis { |redis| redis.get("temp1") }
+      QueueBus.redis { |redis| redis.set('temp1', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp1') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
-
-      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis = QueueBus.redis { |redis| redis.get("temp2") }
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
+
+      QueueBus.redis { |redis| redis.set('temp2', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp2') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
     end
 
-    it "special value should go back and forth into redis" do
-      matcher = Matcher.new("name" => :blank)
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+    it 'special value should go back and forth into redis' do
+      matcher = Matcher.new('name' => :blank)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
 
-      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis= QueueBus.redis { |redis| redis.get("temp1") }
+      QueueBus.redis { |redis| redis.set('temp1', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp1') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
 
-      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis= QueueBus.redis { |redis| redis.get("temp2") }
+      QueueBus.redis { |redis| redis.set('temp2', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp2') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
     end
   end
 end

data/spec/publish_spec.rb

@@ -1,98 +1,120 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe "Publishing an event" do
+require 'spec_helper'
 
+describe 'Publishing an event' do
   before(:each) do
     Timecop.freeze
-    allow(QueueBus).to receive(:generate_uuid).and_return("idfhlkj")
+    allow(QueueBus).to receive(:generate_uuid).and_return('idfhlkj')
   end
   after(:each) do
     Timecop.return
   end
-  let(:bus_attrs) { {"bus_class_proxy"=>"QueueBus::Driver",
-                     "bus_published_at" => Time.now.to_i,
-                     "bus_id"=>"#{Time.now.to_i}-idfhlkj",
-                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+  let(:bus_attrs) do
+    { 'bus_class_proxy' => 'QueueBus::Driver',
+      'bus_published_at' => Time.now.to_i,
+      'bus_id' => "#{Time.now.to_i}-idfhlkj",
+      'bus_app_hostname' => `hostname 2>&1`.strip.sub(/.local/, '') }
+  end
 
-  it "should add it to Redis" do
-    hash = {:one => 1, "two" => "here", "id" => 12 }
-    event_name = "event_name"
+  it 'should add it to Redis' do
+    hash = { :one => 1, 'two' => 'here', 'id' => 12 }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    expect(hash["args"].size).to eq(1)
-    expect(JSON.parse(hash["args"].first)).to eq({"bus_event_type" => event_name, "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs))
-
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ 'bus_event_type' => event_name, 'two' => 'here', 'one' => 1, 'id' => 12 }.merge(bus_attrs))
   end
 
-  it "should use the id if given" do
-    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
-    event_name = "event_name"
+  it 'should use the id if given' do
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    expect(hash["args"].size).to eq(1)
-    expect(JSON.parse(hash["args"].first)).to eq({"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given'))
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ 'bus_event_type' => event_name, 'two' => 'here', 'one' => 1 }.merge(bus_attrs).merge('bus_id' => 'app-given'))
   end
 
-  it "should add metadata via callback" do
+  it 'should add metadata via callback' do
     myval = 0
     QueueBus.before_publish = lambda { |att|
-      att["mine"] = 4
+      att['mine'] = 4
       myval += 1
     }
 
-    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
-    event_name = "event_name"
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    att = JSON.parse(hash["args"].first)
-    expect(att["mine"]).to eq(4)
+    att = JSON.parse(hash['args'].first)
+    expect(att['mine']).to eq(4)
     expect(myval).to eq(1)
   end
 
-  it "should set the timezone and locale if available" do
+  it 'should add context metadata if wrapping publisher with in_context' do
+    expect(QueueBus.context).to be_nil
+
+    bus_context = 'batch_processing'
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+
+    event_name = 'event_name'
+    
+    QueueBus.in_context(:batch_processing) do
+      QueueBus.publish(event_name, hash)
+    end
+    
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
+    hash = JSON.parse(val)
+
+    att = JSON.parse(hash['args'].first)
+    expect(att['bus_context']).to eq(bus_context)
+
+    expect(QueueBus.context).to be_nil
+
+  end
+
+  it 'should set the timezone and locale if available' do
     expect(defined?(I18n)).to be_nil
     expect(Time.respond_to?(:zone)).to eq(false)
 
-    stub_const("I18n", Class.new)
-    allow(I18n).to receive(:locale).and_return("jp")
+    stub_const('I18n', Class.new)
+    allow(I18n).to receive(:locale).and_return('jp')
 
-    allow(Time).to receive(:zone).and_return(double('zone', :name => "EST"))
+    allow(Time).to receive(:zone).and_return(double('zone', name: 'EST'))
 
-    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
-    event_name = "event_name"
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    att = JSON.parse(hash["args"].first)
-    expect(att["bus_locale"]).to eq("jp")
-    expect(att["bus_timezone"]).to eq("EST")
+    expect(hash['class']).to eq('QueueBus::Worker')
+    att = JSON.parse(hash['args'].first)
+    expect(att['bus_locale']).to eq('jp')
+    expect(att['bus_timezone']).to eq('EST')
   end
-
 end

data/spec/publisher_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Publisher do
-    it "should call publish as expected"
+    it 'should call publish as expected'
   end
 end

data/spec/rider_spec.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Rider do
-    it "should call execute" do
+    it 'should call execute' do
       expect(QueueBus).to receive(:dispatcher_execute)
-      Rider.perform("bus_rider_app_key" => "app", "bus_rider_sub_key" => "sub", "ok" => true, "bus_event_type" => "event_name")
+      Rider.perform('bus_rider_app_key' => 'app', 'bus_rider_sub_key' => 'sub', 'ok' => true, 'bus_event_type' => 'event_name')
     end
 
-    it "should change the value" do
-      QueueBus.dispatch("r1") do
-        subscribe "event_name" do |attributes|
+    it 'should change the value' do
+      QueueBus.dispatch('r1') do
+        subscribe 'event_name' do |attributes|
           Runner1.run(attributes)
         end
       end
       expect(Runner1.value).to eq(0)
-      Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
-      Rider.perform("bus_rider_app_key" => "other", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
+      Rider.perform('bus_locale' => 'en', 'bus_timezone' => 'PST', 'bus_rider_app_key' => 'r1', 'bus_rider_sub_key' => 'event_name', 'ok' => true, 'bus_event_type' => 'event_name')
+      Rider.perform('bus_rider_app_key' => 'other', 'bus_rider_sub_key' => 'event_name', 'ok' => true, 'bus_event_type' => 'event_name')
       expect(Runner1.value).to eq(1)
     end
 
-    it "should set the timezone and locale if present" do
-      QueueBus.dispatch("r1") do
-        subscribe "event_name" do |attributes|
+    it 'should set the timezone and locale if present' do
+      QueueBus.dispatch('r1') do
+        subscribe 'event_name' do |attributes|
           Runner1.run(attributes)
         end
       end
@@ -29,11 +31,11 @@ module QueueBus
       expect(defined?(I18n)).to be_nil
       expect(Time.respond_to?(:zone)).to eq(false)
 
-      stub_const("I18n", Class.new)
-      expect(I18n).to receive(:locale=).with("en")
-      expect(Time).to receive(:zone=).with("PST")
+      stub_const('I18n', Class.new)
+      expect(I18n).to receive(:locale=).with('en')
+      expect(Time).to receive(:zone=).with('PST')
 
-      Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
+      Rider.perform('bus_locale' => 'en', 'bus_timezone' => 'PST', 'bus_rider_app_key' => 'r1', 'bus_rider_sub_key' => 'event_name', 'ok' => true, 'bus_event_type' => 'event_name')
     end
   end
 end