launchdarkly-server-sdk 5.5.7

data/spec/event_summarizer_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe LaunchDarkly::EventSummarizer do
+  subject { LaunchDarkly::EventSummarizer }
+
+  let(:user) { { key: "key" } }
+
+  it "does not add identify event to summary" do
+    es = subject.new
+    snapshot = es.snapshot
+    es.summarize_event({ kind: "identify", user: user })
+
+    expect(es.snapshot).to eq snapshot
+  end
+
+  it "does not add custom event to summary" do
+    es = subject.new
+    snapshot = es.snapshot
+    es.summarize_event({ kind: "custom", key: "whatever", user: user })
+
+    expect(es.snapshot).to eq snapshot
+  end
+
+  it "tracks start and end dates" do
+    es = subject.new
+    flag = { key: "key" }
+    event1 = { kind: "feature", creationDate: 2000, user: user }
+    event2 = { kind: "feature", creationDate: 1000, user: user }
+    event3 = { kind: "feature", creationDate: 1500, user: user }
+    es.summarize_event(event1)
+    es.summarize_event(event2)
+    es.summarize_event(event3)
+    data = es.snapshot
+
+    expect(data.start_date).to be 1000
+    expect(data.end_date).to be 2000
+  end
+
+  it "counts events" do
+    es = subject.new
+    flag1 = { key: "key1", version: 11 }
+    flag2 = { key: "key2", version: 22 }
+    event1 = { kind: "feature", key: "key1", version: 11, user: user, variation: 1, value: "value1", default: "default1" }
+    event2 = { kind: "feature", key: "key1", version: 11, user: user, variation: 2, value: "value2", default: "default1" }
+    event3 = { kind: "feature", key: "key2", version: 22, user: user, variation: 1, value: "value99", default: "default2" }
+    event4 = { kind: "feature", key: "key1", version: 11, user: user, variation: 1, value: "value1", default: "default1" }
+    event5 = { kind: "feature", key: "badkey", user: user, variation: nil, value: "default3", default: "default3" }
+    [event1, event2, event3, event4, event5].each { |e| es.summarize_event(e) }
+    data = es.snapshot
+
+    expectedCounters = {
+      { key: "key1", version: 11, variation: 1 } =>
+        { count: 2, value: "value1", default: "default1" },
+      { key: "key1", version: 11, variation: 2 } =>
+        { count: 1, value: "value2", default: "default1" },
+      { key: "key2", version: 22, variation: 1 } =>
+        { count: 1, value: "value99", default: "default2" },
+      { key: "badkey", version: nil, variation: nil } =>
+        { count: 1, value: "default3", default: "default3" }
+    }
+    expect(data.counters).to eq expectedCounters
+  end
+end

data/spec/events_spec.rb

@@ -0,0 +1,642 @@
+require "http_util"
+require "spec_helper"
+require "time"
+
+describe LaunchDarkly::EventProcessor do
+  subject { LaunchDarkly::EventProcessor }
+
+  let(:default_config) { LaunchDarkly::Config.new }
+  let(:hc) { FakeHttpClient.new }
+  let(:user) { { key: "userkey", name: "Red" } }
+  let(:filtered_user) { { key: "userkey", privateAttrs: [ "name" ] } }
+  let(:numeric_user) { { key: 1, secondary: 2, ip: 3, country: 4, email: 5, firstName: 6, lastName: 7,
+    avatar: 8, name: 9, anonymous: false, custom: { age: 99 } } }
+  let(:stringified_numeric_user) { { key: '1', secondary: '2', ip: '3', country: '4', email: '5', firstName: '6',
+    lastName: '7', avatar: '8', name: '9', anonymous: false, custom: { age: 99 } } }
+
+  after(:each) do
+    if !@ep.nil?
+      @ep.stop
+    end
+  end
+
+  it "queues identify event" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    e = { kind: "identify", key: user[:key], user: user }
+    @ep.add_event(e)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(e)
+  end
+
+  it "filters user in identify event" do
+    config = LaunchDarkly::Config.new(all_attributes_private: true)
+    @ep = subject.new("sdk_key", config, hc)
+    e = { kind: "identify", key: user[:key], user: user }
+    @ep.add_event(e)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly({
+      kind: "identify",
+      key: user[:key],
+      creationDate: e[:creationDate],
+      user: filtered_user
+    })
+  end
+
+  it "stringifies built-in user attributes in identify event" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    flag = { key: "flagkey", version: 11 }
+    e = { kind: "identify", key: numeric_user[:key], user: numeric_user }
+    @ep.add_event(e)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      kind: "identify",
+      key: numeric_user[:key].to_s,
+      creationDate: e[:creationDate],
+      user: stringified_numeric_user
+    )
+  end
+
+  it "queues individual feature event with index event" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    flag = { key: "flagkey", version: 11 }
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, user)),
+      eq(feature_event(fe, flag, false, nil)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "filters user in index event" do
+    config = LaunchDarkly::Config.new(all_attributes_private: true)
+    @ep = subject.new("sdk_key", config, hc)
+    flag = { key: "flagkey", version: 11 }
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, filtered_user)),
+      eq(feature_event(fe, flag, false, nil)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "stringifies built-in user attributes in index event" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    flag = { key: "flagkey", version: 11 }
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: numeric_user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, stringified_numeric_user)),
+      eq(feature_event(fe, flag, false, nil)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "can include inline user in feature event" do
+    config = LaunchDarkly::Config.new(inline_users_in_events: true)
+    @ep = subject.new("sdk_key", config, hc)
+    flag = { key: "flagkey", version: 11 }
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(feature_event(fe, flag, false, user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "stringifies built-in user attributes in feature event" do
+    config = LaunchDarkly::Config.new(inline_users_in_events: true)
+    @ep = subject.new("sdk_key", config, hc)
+    flag = { key: "flagkey", version: 11 }
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: numeric_user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(feature_event(fe, flag, false, stringified_numeric_user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "filters user in feature event" do
+    config = LaunchDarkly::Config.new(all_attributes_private: true, inline_users_in_events: true)
+    @ep = subject.new("sdk_key", config, hc)
+    flag = { key: "flagkey", version: 11 }
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(feature_event(fe, flag, false, filtered_user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "still generates index event if inline_users is true but feature event was not tracked" do
+    config = LaunchDarkly::Config.new(inline_users_in_events: true)
+    @ep = subject.new("sdk_key", config, hc)
+    flag = { key: "flagkey", version: 11 }
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: false
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "sets event kind to debug if flag is temporarily in debug mode" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    flag = { key: "flagkey", version: 11 }
+    future_time = (Time.now.to_f * 1000).to_i + 1000000
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: false, debugEventsUntilDate: future_time
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, user)),
+      eq(feature_event(fe, flag, true, user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "can be both debugging and tracking an event" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    flag = { key: "flagkey", version: 11 }
+    future_time = (Time.now.to_f * 1000).to_i + 1000000
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: true, debugEventsUntilDate: future_time
+    }
+    @ep.add_event(fe)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, user)),
+      eq(feature_event(fe, flag, false, nil)),
+      eq(feature_event(fe, flag, true, user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "ends debug mode based on client time if client time is later than server time" do
+    @ep = subject.new("sdk_key", default_config, hc)
+
+    # Pick a server time that is somewhat behind the client time
+    server_time = (Time.now.to_f * 1000).to_i - 20000
+
+    # Send and flush an event we don't care about, just to set the last server time
+    hc.set_server_time(server_time)
+    @ep.add_event({ kind: "identify", user: { key: "otherUser" }})
+    flush_and_get_events
+
+    # Now send an event with debug mode on, with a "debug until" time that is further in
+    # the future than the server time, but in the past compared to the client.
+    flag = { key: "flagkey", version: 11 }
+    debug_until = server_time + 1000
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: false, debugEventsUntilDate: debug_until
+    }
+    @ep.add_event(fe)
+
+    # Should get a summary event only, not a full feature event
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "ends debug mode based on server time if server time is later than client time" do
+    @ep = subject.new("sdk_key", default_config, hc)
+
+    # Pick a server time that is somewhat ahead of the client time
+    server_time = (Time.now.to_f * 1000).to_i + 20000
+
+    # Send and flush an event we don't care about, just to set the last server time
+    hc.set_server_time(server_time)
+    @ep.add_event({ kind: "identify", user: { key: "otherUser" }})
+    flush_and_get_events
+
+    # Now send an event with debug mode on, with a "debug until" time that is further in
+    # the future than the server time, but in the past compared to the client.
+    flag = { key: "flagkey", version: 11 }
+    debug_until = server_time - 1000
+    fe = {
+      kind: "feature", key: "flagkey", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: false, debugEventsUntilDate: debug_until
+    }
+    @ep.add_event(fe)
+
+    # Should get a summary event only, not a full feature event
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe, user)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "generates only one index event for multiple events with same user" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    flag1 = { key: "flagkey1", version: 11 }
+    flag2 = { key: "flagkey2", version: 22 }
+    future_time = (Time.now.to_f * 1000).to_i + 1000000
+    fe1 = {
+      kind: "feature", key: "flagkey1", version: 11, user: user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    fe2 = {
+      kind: "feature", key: "flagkey2", version: 22, user: user,
+      variation: 1, value: "value", trackEvents: true
+    }
+    @ep.add_event(fe1)
+    @ep.add_event(fe2)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe1, user)),
+      eq(feature_event(fe1, flag1, false, nil)),
+      eq(feature_event(fe2, flag2, false, nil)),
+      include(:kind => "summary")
+    )
+  end
+
+  it "summarizes non-tracked events" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    flag1 = { key: "flagkey1", version: 11 }
+    flag2 = { key: "flagkey2", version: 22 }
+    future_time = (Time.now.to_f * 1000).to_i + 1000000
+    fe1 = {
+      kind: "feature", key: "flagkey1", version: 11, user: user,
+      variation: 1, value: "value1", default: "default1"
+    }
+    fe2 = {
+      kind: "feature", key: "flagkey2", version: 22, user: user,
+      variation: 2, value: "value2", default: "default2"
+    }
+    @ep.add_event(fe1)
+    @ep.add_event(fe2)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(fe1, user)),
+      eq({
+        kind: "summary",
+        startDate: fe1[:creationDate],
+        endDate: fe2[:creationDate],
+        features: {
+          flagkey1: {
+            default: "default1",
+            counters: [
+              { version: 11, variation: 1, value: "value1", count: 1 }
+            ]
+          },
+          flagkey2: {
+            default: "default2",
+            counters: [
+              { version: 22, variation: 2, value: "value2", count: 1 }
+            ]
+          }
+        }
+      })
+    )
+  end
+
+  it "queues custom event with user" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    e = { kind: "custom", key: "eventkey", user: user, data: { thing: "stuff" } }
+    @ep.add_event(e)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(index_event(e, user)),
+      eq(custom_event(e, nil))
+    )
+  end
+
+  it "can include inline user in custom event" do
+    config = LaunchDarkly::Config.new(inline_users_in_events: true)
+    @ep = subject.new("sdk_key", config, hc)
+    e = { kind: "custom", key: "eventkey", user: user, data: { thing: "stuff" } }
+    @ep.add_event(e)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(custom_event(e, user))
+    )
+  end
+
+  it "filters user in custom event" do
+    config = LaunchDarkly::Config.new(all_attributes_private: true, inline_users_in_events: true)
+    @ep = subject.new("sdk_key", config, hc)
+    e = { kind: "custom", key: "eventkey", user: user, data: { thing: "stuff" } }
+    @ep.add_event(e)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(custom_event(e, filtered_user))
+    )
+  end
+
+  it "stringifies built-in user attributes in custom event" do
+    config = LaunchDarkly::Config.new(inline_users_in_events: true)
+    @ep = subject.new("sdk_key", config, hc)
+    e = { kind: "custom", key: "eventkey", user: numeric_user }
+    @ep.add_event(e)
+
+    output = flush_and_get_events
+    expect(output).to contain_exactly(
+      eq(custom_event(e, stringified_numeric_user))
+    )
+  end
+
+  it "does a final flush when shutting down" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    e = { kind: "identify", key: user[:key], user: user }
+    @ep.add_event(e)
+    
+    @ep.stop
+
+    output = get_events_from_last_request
+    expect(output).to contain_exactly(e)
+  end
+
+  it "sends nothing if there are no events" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    @ep.flush
+    expect(hc.get_request).to be nil
+  end
+
+  it "sends SDK key" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    e = { kind: "identify", user: user }
+    @ep.add_event(e)
+
+    @ep.flush
+    @ep.wait_until_inactive
+    
+    expect(hc.get_request["authorization"]).to eq "sdk_key"
+  end
+
+  def verify_unrecoverable_http_error(status)
+    @ep = subject.new("sdk_key", default_config, hc)
+    e = { kind: "identify", user: user }
+    @ep.add_event(e)
+
+    hc.set_response_status(status)
+    @ep.flush
+    @ep.wait_until_inactive
+    expect(hc.get_request).not_to be_nil
+    hc.reset
+
+    @ep.add_event(e)
+    @ep.flush
+    @ep.wait_until_inactive
+    expect(hc.get_request).to be_nil
+  end
+
+  def verify_recoverable_http_error(status)
+    @ep = subject.new("sdk_key", default_config, hc)
+    e = { kind: "identify", user: user }
+    @ep.add_event(e)
+
+    hc.set_response_status(503)
+    @ep.flush
+    @ep.wait_until_inactive
+
+    expect(hc.get_request).not_to be_nil
+    expect(hc.get_request).not_to be_nil
+    expect(hc.get_request).to be_nil  # no 3rd request
+
+    # now verify that a subsequent flush still generates a request
+    hc.reset
+    @ep.add_event(e)
+    @ep.flush
+    @ep.wait_until_inactive
+    expect(hc.get_request).not_to be_nil
+  end
+
+  it "stops posting events after getting a 401 error" do
+    verify_unrecoverable_http_error(401)
+  end
+
+  it "stops posting events after getting a 403 error" do
+    verify_unrecoverable_http_error(403)
+  end
+
+  it "retries after 408 error" do
+    verify_recoverable_http_error(408)
+  end
+
+  it "retries after 429 error" do
+    verify_recoverable_http_error(429)
+  end
+
+  it "retries after 503 error" do
+    verify_recoverable_http_error(503)
+  end
+
+  it "retries flush once after connection error" do
+    @ep = subject.new("sdk_key", default_config, hc)
+    e = { kind: "identify", user: user }
+    @ep.add_event(e)
+
+    hc.set_exception(IOError.new("deliberate error"))
+    @ep.flush
+    @ep.wait_until_inactive
+
+    expect(hc.get_request).not_to be_nil
+    expect(hc.get_request).not_to be_nil
+    expect(hc.get_request).to be_nil  # no 3rd request
+  end
+
+  it "makes actual HTTP request with correct headers" do
+    e = { kind: "identify", key: user[:key], user: user }
+    with_server do |server|
+      server.setup_ok_response("/bulk", "")
+
+      @ep = subject.new("sdk_key", LaunchDarkly::Config.new(events_uri: server.base_uri.to_s))
+      @ep.add_event(e)
+      @ep.flush
+
+      req = server.await_request
+      expect(req.header).to include({
+        "authorization" => [ "sdk_key" ],
+        "content-type" => [ "application/json" ],
+        "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ],
+        "x-launchdarkly-event-schema" => [ "3" ]
+      })
+    end
+  end
+
+  it "can use a proxy server" do
+    e = { kind: "identify", key: user[:key], user: user }
+    with_server do |server|
+      server.setup_ok_response("/bulk", "")
+
+      with_server(StubProxyServer.new) do |proxy|
+        begin
+          ENV["http_proxy"] = proxy.base_uri.to_s
+          @ep = subject.new("sdk_key", LaunchDarkly::Config.new(events_uri: server.base_uri.to_s))
+          @ep.add_event(e)
+          @ep.flush
+
+          req = server.await_request
+          expect(req["content-type"]).to eq("application/json")
+        ensure
+          ENV["http_proxy"] = nil
+        end
+      end
+    end
+  end
+
+  def index_event(e, user)
+    {
+      kind: "index",
+      creationDate: e[:creationDate],
+      user: user
+    }
+  end
+
+  def feature_event(e, flag, debug, inline_user)
+    out = {
+      kind: debug ? "debug" : "feature",
+      creationDate: e[:creationDate],
+      key: flag[:key],
+      variation: e[:variation],
+      version: flag[:version],
+      value: e[:value]
+    }
+    if inline_user.nil?
+      out[:userKey] = e[:user][:key]
+    else
+      out[:user] = inline_user
+    end
+    out
+  end
+
+  def custom_event(e, inline_user)
+    out = {
+      kind: "custom",
+      creationDate: e[:creationDate],
+      key: e[:key]
+    }
+    out[:data] = e[:data] if e.has_key?(:data)
+    if inline_user.nil?
+      out[:userKey] = e[:user][:key]
+    else
+      out[:user] = inline_user
+    end
+    out
+  end
+
+  def flush_and_get_events
+    @ep.flush
+    @ep.wait_until_inactive
+    get_events_from_last_request
+  end
+
+  def get_events_from_last_request
+    req = hc.get_request
+    JSON.parse(req.body, symbolize_names: true)
+  end
+
+  class FakeHttpClient
+    def initialize
+      reset
+    end
+
+    def set_response_status(status)
+      @status = status
+    end
+
+    def set_server_time(time_millis)
+      @server_time = Time.at(time_millis.to_f / 1000)
+    end
+
+    def set_exception(e)
+      @exception = e
+    end
+
+    def reset
+      @requests = []
+      @status = 200
+    end
+
+    def request(req)
+      @requests.push(req)
+      if @exception
+        raise @exception
+      else
+        headers = {}
+        if @server_time
+          headers["Date"] = @server_time.httpdate
+        end
+        FakeResponse.new(@status ? @status : 200, headers)
+      end
+    end
+
+    def start
+    end
+
+    def started?
+      false
+    end
+
+    def finish
+    end
+
+    def get_request
+      @requests.shift
+    end
+  end
+
+  class FakeResponse
+    include Net::HTTPHeader
+
+    attr_reader :code
+
+    def initialize(status, headers)
+      @code = status.to_s
+      initialize_http_header(headers)
+    end
+  end
+end