launchdarkly-server-sdk 6.4.0 → 7.0.1

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

@@ -0,0 +1,145 @@
+module LaunchDarkly
+  module Impl
+    class ContextFilter
+      #
+      # @param all_attributes_private [Boolean]
+      # @param private_attributes [Array<String>]
+      #
+      def initialize(all_attributes_private, private_attributes)
+        @all_attributes_private = all_attributes_private
+
+        @private_attributes = []
+        private_attributes.each do |attribute|
+          reference = LaunchDarkly::Reference.create(attribute)
+          @private_attributes << reference if reference.error.nil?
+        end
+      end
+
+      #
+      # Return a hash representation of the provided context with attribute
+      # redaction applied.
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @return [Hash]
+      #
+      def filter(context)
+        return filter_single_context(context, true) unless context.multi_kind?
+
+        filtered = {kind: 'multi'}
+        (0...context.individual_context_count).each do |i|
+          c = context.individual_context(i)
+          next if c.nil?
+
+          filtered[c.kind] = filter_single_context(c, false)
+        end
+
+        filtered
+      end
+
+      #
+      # Apply redaction rules for a single context.
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @param include_kind [Boolean]
+      # @return [Hash]
+      #
+      private def filter_single_context(context, include_kind)
+        filtered = {key: context.key}
+
+        filtered[:kind] = context.kind if include_kind
+        filtered[:anonymous] = true if context.get_value(:anonymous)
+
+        redacted = []
+        private_attributes = @private_attributes.concat(context.private_attributes)
+
+        name = context.get_value(:name)
+        if !name.nil? && !check_whole_attribute_private(:name, private_attributes, redacted)
+          filtered[:name] = name
+        end
+
+        context.get_custom_attribute_names.each do |attribute|
+          unless check_whole_attribute_private(attribute, private_attributes, redacted)
+            value = context.get_value(attribute)
+            filtered[attribute] = redact_json_value(nil, attribute, value, private_attributes, redacted)
+          end
+        end
+
+        filtered[:_meta] = {redactedAttributes: redacted} unless redacted.empty?
+
+        filtered
+      end
+
+      #
+      # Check if an entire attribute should be redacted.
+      #
+      # @param attribute [Symbol]
+      # @param private_attributes [Array<Reference>]
+      # @param redacted [Array<Symbol>]
+      # @return [Boolean]
+      #
+      private def check_whole_attribute_private(attribute, private_attributes, redacted)
+        if @all_attributes_private
+          redacted << attribute
+          return true
+        end
+
+        private_attributes.each do |private_attribute|
+          if private_attribute.component(0) == attribute && private_attribute.depth == 1
+            redacted << attribute
+            return true
+          end
+        end
+
+        false
+      end
+
+      #
+      # Apply redaction rules to the provided value.
+      #
+      # @param parent_path [Array<String>, nil]
+      # @param name [String]
+      # @param value [any]
+      # @param private_attributes [Array<Reference>]
+      # @param redacted [Array<Symbol>]
+      # @return [any]
+      #
+      private def redact_json_value(parent_path, name, value, private_attributes, redacted)
+        return value unless value.is_a?(Hash)
+
+        ret = {}
+        current_path = parent_path.clone || []
+        current_path << name
+
+        value.each do |k, v|
+          was_redacted = false
+          private_attributes.each do |private_attribute|
+            next unless private_attribute.depth == (current_path.count + 1)
+
+            component = private_attribute.component(current_path.count)
+            next unless component == k
+
+            match = true
+            (0...current_path.count).each do |i|
+              unless private_attribute.component(i) == current_path[i]
+                match = false
+                break
+              end
+            end
+
+            if match
+              redacted << private_attribute.raw_path.to_sym
+              was_redacted = true
+              break
+            end
+          end
+
+          unless was_redacted
+            ret[k] = redact_json_value(current_path, k, v, private_attributes, redacted)
+          end
+        end
+
+        ret
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module LaunchDarkly
       def self.create_diagnostic_id(sdk_key)
         {
           diagnosticId: SecureRandom.uuid,
-          sdkKeySuffix: sdk_key[-6..-1] || sdk_key
+          sdkKeySuffix: sdk_key[-6..-1] || sdk_key,
         }
       end
 
@@ -25,16 +25,16 @@ module LaunchDarkly
       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
+          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 })
@@ -57,7 +57,7 @@ module LaunchDarkly
           droppedEvents: dropped_events,
           deduplicatedUsers: deduplicated_users,
           eventsInLastBatch: events_in_last_batch,
-          streamInits: previous_stream_inits
+          streamInits: previous_stream_inits,
         }
         @data_since_date = current_time
         event
@@ -73,12 +73,11 @@ module LaunchDarkly
           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),
+          userKeysCapacity: config.context_keys_capacity,
+          userKeysFlushIntervalMillis: self.seconds_to_millis(config.context_keys_flush_interval),
           usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY') || ENV.has_key?('HTTPS_PROXY'),
           usingRelayDaemon: config.use_ldd?,
         }
@@ -88,7 +87,7 @@ module LaunchDarkly
       def self.make_sdk_data(config)
         ret = {
           name: 'ruby-server-sdk',
-          version: LaunchDarkly::VERSION
+          version: LaunchDarkly::VERSION,
         }
         if config.wrapper_name
           ret[:wrapperName] = config.wrapper_name
@@ -105,7 +104,7 @@ module LaunchDarkly
           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'
+          rubyImplementation: Object.constants.include?(:RUBY_ENGINE) ? RUBY_ENGINE : 'unknown',
         }
       end