launchdarkly-server-sdk 5.6.2 → 5.7.0

data/lib/ldclient-rb/flags_state.rb

@@ -22,7 +22,7 @@ module LaunchDarkly
       meta = {}
       with_details = !details_only_if_tracked || flag[:trackEvents]
       if !with_details && flag[:debugEventsUntilDate]
-        with_details = flag[:debugEventsUntilDate] > (Time.now.to_f * 1000).to_i
+        with_details = flag[:debugEventsUntilDate] > Impl::Util::current_time_millis
       end
       if with_details
         meta[:version] = flag[:version]

data/lib/ldclient-rb/impl/diagnostic_events.rb

@@ -0,0 +1,130 @@
+require "ldclient-rb/impl/util"
+
+require "rbconfig"
+require "securerandom"
+
+module LaunchDarkly
+  module Impl
+    class DiagnosticAccumulator
+      def self.create_diagnostic_id(sdk_key)
+        {
+          diagnosticId: SecureRandom.uuid,
+          sdkKeySuffix: sdk_key[-6..-1] || sdk_key
+        }
+      end
+
+      def initialize(diagnostic_id)
+        @id = diagnostic_id
+        @lock = Mutex.new
+        self.reset(Util.current_time_millis)
+      end
+
+      def reset(time)
+        @data_since_date = time
+        @stream_inits = []
+      end
+
+      def create_init_event(config)
+        return {
+          kind: 'diagnostic-init',
+          creationDate: Util.current_time_millis,
+          id: @id,
+          configuration: DiagnosticAccumulator.make_config_data(config),
+          sdk: DiagnosticAccumulator.make_sdk_data(config),
+          platform: DiagnosticAccumulator.make_platform_data
+        }
+      end
+      
+      def record_stream_init(timestamp, failed, duration_millis)
+        @lock.synchronize do
+          @stream_inits.push({ timestamp: timestamp, failed: failed, durationMillis: duration_millis })
+        end
+      end
+
+      def create_periodic_event_and_reset(dropped_events, deduplicated_users, events_in_last_batch)
+        previous_stream_inits = @lock.synchronize do
+          si = @stream_inits
+          @stream_inits = []
+          si
+        end
+
+        current_time = Util.current_time_millis
+        event = {
+          kind: 'diagnostic',
+          creationDate: current_time,
+          id: @id,
+          dataSinceDate: @data_since_date,
+          droppedEvents: dropped_events,
+          deduplicatedUsers: deduplicated_users,
+          eventsInLastBatch: events_in_last_batch,
+          streamInits: previous_stream_inits
+        }
+        @data_since_date = current_time
+        event
+      end
+
+      def self.make_config_data(config)
+        ret = {
+          allAttributesPrivate: config.all_attributes_private,
+          connectTimeoutMillis: self.seconds_to_millis(config.connect_timeout),
+          customBaseURI: config.base_uri != Config.default_base_uri,
+          customEventsURI: config.events_uri != Config.default_events_uri,
+          customStreamURI: config.stream_uri != Config.default_stream_uri,
+          diagnosticRecordingIntervalMillis: self.seconds_to_millis(config.diagnostic_recording_interval),
+          eventsCapacity: config.capacity,
+          eventsFlushIntervalMillis: self.seconds_to_millis(config.flush_interval),
+          inlineUsersInEvents: config.inline_users_in_events,
+          pollingIntervalMillis: self.seconds_to_millis(config.poll_interval),
+          socketTimeoutMillis: self.seconds_to_millis(config.read_timeout),
+          streamingDisabled: !config.stream?,
+          userKeysCapacity: config.user_keys_capacity,
+          userKeysFlushIntervalMillis: self.seconds_to_millis(config.user_keys_flush_interval),
+          usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY'),
+          usingRelayDaemon: config.use_ldd?,
+        }
+        ret
+      end
+
+      def self.make_sdk_data(config)
+        ret = {
+          name: 'ruby-server-sdk',
+          version: LaunchDarkly::VERSION
+        }
+        if config.wrapper_name
+          ret[:wrapperName] = config.wrapper_name
+          ret[:wrapperVersion] = config.wrapper_version
+        end
+        ret
+      end
+
+      def self.make_platform_data
+        conf = RbConfig::CONFIG
+        {
+          name: 'ruby',
+          osArch: conf['host_cpu'],
+          osName: self.normalize_os_name(conf['host_os']),
+          osVersion: 'unknown', # there seems to be no portable way to detect this in Ruby
+          rubyVersion: conf['ruby_version'],
+          rubyImplementation: Object.constants.include?(:RUBY_ENGINE) ? RUBY_ENGINE : 'unknown'
+        }
+      end
+
+      def self.normalize_os_name(name)
+        case name
+        when /linux|arch/i
+          'Linux'
+        when /darwin/i
+          'MacOS'
+        when /mswin|windows/i
+          'Windows'
+        else
+          name
+        end
+      end
+
+      def self.seconds_to_millis(s)
+        (s * 1000).to_i
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/event_sender.rb

@@ -0,0 +1,72 @@
+require "securerandom"
+
+module LaunchDarkly
+  module Impl
+    EventSenderResult = Struct.new(:success, :must_shutdown, :time_from_server)
+
+    class EventSender
+      CURRENT_SCHEMA_VERSION = 3
+      DEFAULT_RETRY_INTERVAL = 1
+
+      def initialize(sdk_key, config, http_client = nil, retry_interval = DEFAULT_RETRY_INTERVAL)
+        @client = http_client ? http_client : LaunchDarkly::Util.new_http_client(config.events_uri, config)
+        @sdk_key = sdk_key
+        @config = config
+        @events_uri = config.events_uri + "/bulk"
+        @diagnostic_uri = config.events_uri + "/diagnostic"
+        @logger = config.logger
+        @retry_interval = retry_interval
+      end
+
+      def send_event_data(event_data, is_diagnostic)
+        uri = is_diagnostic ? @diagnostic_uri : @events_uri
+        payload_id = is_diagnostic ? nil : SecureRandom.uuid
+        description = is_diagnostic ? 'diagnostic event' : "#{event_data.length} events"
+        res = nil
+        (0..1).each do |attempt|
+          if attempt > 0
+            @logger.warn { "[LDClient] Will retry posting events after #{@retry_interval} second" }
+            sleep(@retry_interval)
+          end
+          begin
+            @client.start if !@client.started?
+            @logger.debug { "[LDClient] sending #{description}: #{body}" }
+            req = Net::HTTP::Post.new(uri)
+            req.content_type = "application/json"
+            req.body = event_data
+            Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| req[k] = v }
+            if !is_diagnostic
+              req["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
+              req["X-LaunchDarkly-Payload-ID"] = payload_id
+            end
+            req["Connection"] = "keep-alive"
+            res = @client.request(req)
+          rescue StandardError => exn
+            @logger.warn { "[LDClient] Error sending events: #{exn.inspect}." }
+            next
+          end
+          status = res.code.to_i
+          if status >= 200 && status < 300
+            res_time = nil
+            if !res["date"].nil?
+              begin
+                res_time = Time.httpdate(res["date"])
+              rescue ArgumentError
+              end
+            end
+            return EventSenderResult.new(true, false, res_time)
+          end
+          must_shutdown = !LaunchDarkly::Util.http_error_recoverable?(status)
+          can_retry = !must_shutdown && attempt == 0
+          message = LaunchDarkly::Util.http_error_message(status, "event delivery", can_retry ? "will retry" : "some events were dropped")
+          @logger.error { "[LDClient] #{message}" }
+          if must_shutdown
+            return EventSenderResult.new(false, true, nil)
+          end
+        end
+        # used up our retries
+        return EventSenderResult.new(false, false, nil)
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/util.rb

@@ -0,0 +1,19 @@
+
+module LaunchDarkly
+  module Impl
+    module Util
+      def self.current_time_millis
+        (Time.now.to_f * 1000).to_i
+      end
+
+      def self.default_http_headers(sdk_key, config)
+        ret = { "Authorization" => sdk_key, "User-Agent" => "RubyClient/" + LaunchDarkly::VERSION }
+        if config.wrapper_name
+          ret["X-LaunchDarkly-Wrapper"] = config.wrapper_name +
+            (config.wrapper_version ? "/" + config.wrapper_version : "")
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/ldclient-rb/ldclient.rb

@@ -1,3 +1,4 @@
+require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/event_factory"
 require "ldclient-rb/impl/store_client_wrapper"
 require "concurrent/atomics"
@@ -46,10 +47,16 @@ module LaunchDarkly
       updated_config.instance_variable_set(:@feature_store, @store)
       @config = updated_config
 
+      if !@config.offline? && @config.send_events && !@config.diagnostic_opt_out?
+        diagnostic_accumulator = Impl::DiagnosticAccumulator.new(Impl::DiagnosticAccumulator.create_diagnostic_id(sdk_key))
+      else
+        diagnostic_accumulator = nil
+      end
+
       if @config.offline? || !@config.send_events
         @event_processor = NullEventProcessor.new
       else
-        @event_processor = EventProcessor.new(sdk_key, config)
+        @event_processor = EventProcessor.new(sdk_key, config, diagnostic_accumulator)
       end
 
       if @config.use_ldd?
@@ -59,7 +66,13 @@ module LaunchDarkly
 
       data_source_or_factory = @config.data_source || self.method(:create_default_data_source)
       if data_source_or_factory.respond_to? :call
-        @data_source = data_source_or_factory.call(sdk_key, @config)
+        # Currently, data source factories take two parameters unless they need to be aware of diagnostic_accumulator, in
+        # which case they take three parameters. This will be changed in the future to use a less awkware mechanism.
+        if data_source_or_factory.arity == 3
+          @data_source = data_source_or_factory.call(sdk_key, @config, diagnostic_accumulator)
+        else
+          @data_source = data_source_or_factory.call(sdk_key, @config)
+        end
       else
         @data_source = data_source_or_factory
       end
@@ -335,13 +348,13 @@ module LaunchDarkly
 
     private
 
-    def create_default_data_source(sdk_key, config)
+    def create_default_data_source(sdk_key, config, diagnostic_accumulator)
       if config.offline?
         return NullUpdateProcessor.new
       end
       requestor = Requestor.new(sdk_key, config)
       if config.stream?
-        StreamProcessor.new(sdk_key, config, requestor)
+        StreamProcessor.new(sdk_key, config, requestor, diagnostic_accumulator)
       else
         config.logger.info { "Disabling streaming API" }
         config.logger.warn { "You should only disable the streaming API if instructed to do so by LaunchDarkly support" }

data/lib/ldclient-rb/requestor.rb

@@ -51,8 +51,7 @@ module LaunchDarkly
       @client.start if !@client.started?
       uri = URI(@config.base_uri + path)
       req = Net::HTTP::Get.new(uri)
-      req["Authorization"] = @sdk_key
-      req["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
+      Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| req[k] = v }
       req["Connection"] = "keep-alive"
       cached = @cache.read(uri)
       if !cached.nil?

data/lib/ldclient-rb/stream.rb

@@ -24,7 +24,7 @@ module LaunchDarkly
 
   # @private
   class StreamProcessor
-    def initialize(sdk_key, config, requestor)
+    def initialize(sdk_key, config, requestor, diagnostic_accumulator = nil)
       @sdk_key = sdk_key
       @config = config
       @feature_store = config.feature_store
@@ -33,6 +33,7 @@ module LaunchDarkly
       @started = Concurrent::AtomicBoolean.new(false)
       @stopped = Concurrent::AtomicBoolean.new(false)
       @ready = Concurrent::Event.new
+      @connection_attempt_start_time = 0
     end
 
     def initialized?
@@ -44,18 +45,17 @@ module LaunchDarkly
 
       @config.logger.info { "[LDClient] Initializing stream connection" }
       
-      headers = {
-        'Authorization' => @sdk_key,
-        'User-Agent' => 'RubyClient/' + LaunchDarkly::VERSION
-      }
+      headers = Impl::Util.default_http_headers(@sdk_key, @config)
       opts = {
         headers: headers,
         read_timeout: READ_TIMEOUT_SECONDS,
         logger: @config.logger
       }
+      log_connection_started
       @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|
         conn.on_event { |event| process_message(event) }
         conn.on_error { |err|
+          log_connection_result(false)
           case err
           when SSE::Errors::HTTPStatusError
             status = err.status
@@ -82,6 +82,7 @@ module LaunchDarkly
     private
 
     def process_message(message)
+      log_connection_result(true)
       method = message.type
       @config.logger.debug { "[LDClient] Stream received #{method} message: #{message.data}" }
       if method == PUT
@@ -137,5 +138,17 @@ module LaunchDarkly
     def key_for_path(kind, path)
       path.start_with?(KEY_PATHS[kind]) ? path[KEY_PATHS[kind].length..-1] : nil
     end
+
+    def log_connection_started
+      @connection_attempt_start_time = Impl::Util::current_time_millis
+    end
+
+    def log_connection_result(is_success)
+      if !@diagnostic_accumulator.nil? && @connection_attempt_start_time > 0
+        @diagnostic_accumulator.record_stream_init(@connection_attempt_start_time, !is_success,
+          Impl::Util::current_time_millis - @connection_attempt_start_time)
+        @connection_attempt_start_time = 0
+      end
+    end
   end
 end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.6.2"
+  VERSION = "5.7.0"
 end

data/spec/diagnostic_events_spec.rb

@@ -0,0 +1,163 @@
+require "ldclient-rb/impl/diagnostic_events"
+
+require "spec_helper"
+
+module LaunchDarkly
+  module Impl
+    describe DiagnosticAccumulator do
+      subject { DiagnosticAccumulator }
+
+      let(:sdk_key) { "sdk_key" }
+      let(:default_id) { subject.create_diagnostic_id("my-key") }
+      let(:default_acc) { subject.new(default_id) }
+
+      it "creates unique ID with SDK key suffix" do
+        id1 = subject.create_diagnostic_id("1234567890")
+        expect(id1[:sdkKeySuffix]).to eq "567890"
+        expect(id1[:diagnosticId]).not_to be_nil
+
+        id2 = subject.create_diagnostic_id("1234567890")
+        expect(id2[:diagnosticId]).not_to eq id1[:diagnosticId]
+      end
+
+      describe "init event" do
+        def expected_default_config
+          {
+            allAttributesPrivate: false,
+            connectTimeoutMillis: Config.default_connect_timeout * 1000,
+            customBaseURI: false,
+            customEventsURI: false,
+            customStreamURI: false,
+            diagnosticRecordingIntervalMillis: Config.default_diagnostic_recording_interval * 1000,
+            eventsCapacity: Config.default_capacity,
+            eventsFlushIntervalMillis: Config.default_flush_interval * 1000,
+            inlineUsersInEvents: false,
+            pollingIntervalMillis: Config.default_poll_interval * 1000,
+            socketTimeoutMillis: Config.default_read_timeout * 1000,
+            streamingDisabled: false,
+            userKeysCapacity: Config.default_user_keys_capacity,
+            userKeysFlushIntervalMillis: Config.default_user_keys_flush_interval * 1000,
+            usingProxy: false,
+            usingRelayDaemon: false
+          }
+        end
+
+        it "has basic fields" do
+          event = default_acc.create_init_event(Config.new)
+          expect(event[:kind]).to eq 'diagnostic-init'
+          expect(event[:creationDate]).not_to be_nil
+          expect(event[:id]).to eq default_id
+        end
+
+        it "can have default config data" do
+          event = default_acc.create_init_event(Config.new)
+          expect(event[:configuration]).to eq expected_default_config
+        end
+
+        it "can have custom config data" do
+          changes_and_expected = [
+            [ { all_attributes_private: true }, { allAttributesPrivate: true } ],
+            [ { connect_timeout: 46 }, { connectTimeoutMillis: 46000 } ],
+            [ { base_uri: 'http://custom' }, { customBaseURI: true } ],
+            [ { events_uri: 'http://custom' }, { customEventsURI: true } ],
+            [ { stream_uri: 'http://custom' }, { customStreamURI: true } ],
+            [ { diagnostic_recording_interval: 9999 }, { diagnosticRecordingIntervalMillis: 9999000 } ],
+            [ { capacity: 4000 }, { eventsCapacity: 4000 } ],
+            [ { flush_interval: 46 }, { eventsFlushIntervalMillis: 46000 } ],
+            [ { inline_users_in_events: true }, { inlineUsersInEvents: true } ],
+            [ { poll_interval: 999 }, { pollingIntervalMillis: 999000 } ],
+            [ { read_timeout: 46 }, { socketTimeoutMillis: 46000 } ],
+            [ { stream: false }, { streamingDisabled: true } ],
+            [ { user_keys_capacity: 999 }, { userKeysCapacity: 999 } ],
+            [ { user_keys_flush_interval: 999 }, { userKeysFlushIntervalMillis: 999000 } ],
+            [ { use_ldd: true }, { usingRelayDaemon: true } ]
+          ]
+          changes_and_expected.each do |config_values, expected_values|
+            config = Config.new(config_values)
+            event = default_acc.create_init_event(config)
+            expect(event[:configuration]).to eq expected_default_config.merge(expected_values)
+          end
+        end
+
+        it "detects proxy" do
+          begin
+            ENV["http_proxy"] = 'http://my-proxy'
+            event = default_acc.create_init_event(Config.new)
+            expect(event[:configuration][:usingProxy]).to be true
+          ensure
+            ENV["http_proxy"] = nil
+          end
+        end
+
+        it "has expected SDK data" do
+          event = default_acc.create_init_event(Config.new)
+          expect(event[:sdk]).to eq ({
+            name: 'ruby-server-sdk',
+            version: LaunchDarkly::VERSION
+          })
+        end
+
+        it "has expected SDK data with wrapper" do
+          event = default_acc.create_init_event(Config.new(wrapper_name: 'my-wrapper', wrapper_version: '2.0'))
+          expect(event[:sdk]).to eq ({
+            name: 'ruby-server-sdk',
+            version: LaunchDarkly::VERSION,
+            wrapperName: 'my-wrapper',
+            wrapperVersion: '2.0'
+          })
+        end
+
+        it "has expected platform data" do
+          event = default_acc.create_init_event(Config.new)
+          expect(event[:platform]).to include ({
+            name: 'ruby'
+          })
+        end
+      end
+
+      describe "periodic event" do
+        it "has correct default values" do
+          acc = subject.new(default_id)
+          event = acc.create_periodic_event_and_reset(2, 3, 4)
+          expect(event).to include({
+            kind: 'diagnostic',
+            id: default_id,
+            droppedEvents: 2,
+            deduplicatedUsers: 3,
+            eventsInLastBatch: 4,
+            streamInits: []
+          })
+          expect(event[:creationDate]).not_to be_nil
+          expect(event[:dataSinceDate]).not_to be_nil
+        end
+
+        it "can add stream init" do
+          acc = subject.new(default_id)
+          acc.record_stream_init(1000, false, 2000)
+          event = acc.create_periodic_event_and_reset(0, 0, 0)
+          expect(event[:streamInits]).to eq [{ timestamp: 1000, failed: false, durationMillis: 2000 }]
+        end
+
+        it "resets fields after creating event" do
+          acc = subject.new(default_id)
+          acc.record_stream_init(1000, false, 2000)
+          event1 = acc.create_periodic_event_and_reset(2, 3, 4)
+          event2 = acc.create_periodic_event_and_reset(5, 6, 7)
+          expect(event1).to include ({
+            droppedEvents: 2,
+            deduplicatedUsers: 3,
+            eventsInLastBatch: 4,
+            streamInits: [{ timestamp: 1000, failed: false, durationMillis: 2000 }]
+          })
+          expect(event2).to include ({
+            dataSinceDate: event1[:creationDate],
+            droppedEvents: 5,
+            deduplicatedUsers: 6,
+            eventsInLastBatch: 7,
+            streamInits: []
+          })
+        end
+      end
+    end
+  end
+end