datadog 2.7.1 → 2.17.0

data/lib/datadog/error_tracking/component.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'collector'
+require_relative 'filters'
+
+module Datadog
+  module ErrorTracking
+    # Component for Error Tracking.
+    #
+    # Only one instance of the Component should ever be active.
+    #
+    # The component instance records every handled exceptions from the configured scopes
+    # (user, third_party packages, specified files or everything).
+    class Component
+      LOCK = Mutex.new
+
+      class << self
+        def build(settings, tracer, logger)
+          return if !settings.respond_to?(:error_tracking) || (settings.error_tracking.handled_errors.nil? &&
+            settings.error_tracking.handled_errors_include.empty?)
+
+          return unless environment_supported?(logger)
+
+          new(
+            tracer: tracer,
+            handled_errors: settings.error_tracking.handled_errors,
+            handled_errors_include: settings.error_tracking.handled_errors_include,
+          ).tap(&:start)
+        end
+
+        def environment_supported?(logger)
+          if RUBY_ENGINE != 'ruby'
+            logger.warn("error tracking: cannot enable error tracking: MRI is required, but running on #{RUBY_ENGINE}")
+            false
+          elsif RUBY_VERSION < '2.7'
+            logger.warn(
+              "error tracking: cannot enable error tracking: Ruby 2.7+ is required, but running
+              on #{RUBY_VERSION}"
+            )
+            false
+          else
+            true
+          end
+        end
+      end
+
+      def initialize(tracer:, handled_errors:, handled_errors_include:)
+        @tracer = tracer
+
+        # Hash containing the paths to the instrumented files
+        @instrumented_files = Set.new unless handled_errors_include.empty?
+        # Array containing file paths, file names and gems names to instrument.
+        # This is coming from the DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE env variable
+        @handled_errors_include = handled_errors_include
+
+        # Filter function is used to filter out the exception
+        # we do not want to report. For instance exception from gems.
+        @filter_function = Filters.generate_filter(handled_errors, @instrumented_files)
+
+        # :rescue event was added in Ruby 3.3
+        #
+        # Before Ruby3.3 the TracePoint listen for :raise events.
+        # If an error is not handled, we will delete the according
+        # span event in the collector.
+        event = (RUBY_VERSION >= '3.3') ? :rescue : :raise
+
+        # This TracePoint is in charge of capturing the handled exceptions
+        # and of adding the corresponding span events to the collector
+        @handled_exc_tracker = create_exc_tracker_trace_point(event)
+
+        if @instrumented_files
+          # The only thing we know about the handled errors is the path of the file
+          # in which the error was rescued. Therefore, we need to retrieve the path
+          # of the files the user want to instrument. This TracePoint is used for that
+          # purpose
+          @include_path_getter = create_script_compiled_trace_point
+        end
+      end
+
+      def create_exc_tracker_trace_point(event)
+        TracePoint.new(event) do |tp|
+          active_span = @tracer.active_span
+          if active_span
+            raised_exception = tp.raised_exception
+            # Note that in 3.2, this will give the path of where the error was raised
+            # which may cause the handled_error_include env variable to malfunction.
+            rescue_file_path = tp.path
+            if @filter_function.call(rescue_file_path)
+              span_event = generate_span_event(raised_exception)
+              LOCK.synchronize do
+                collector = active_span.get_collector_or_initialize { Collector.new }
+                collector.add_span_event(active_span, span_event, raised_exception)
+              end
+            end
+          end
+        end
+      end
+
+      def create_script_compiled_trace_point
+        TracePoint.new(:script_compiled) do |tp|
+          next if tp.eval_script
+
+          path = tp.instruction_sequence.path
+          next if path.nil?
+
+          @handled_errors_include.each do |file_to_instr|
+            # The user can provide either
+            # - absolute_path starting with '/'. In that case the path of the file
+            #   should begin with file_to_instr
+            # - a relative_path starting with './'. In that case, we extend the path
+            #   and it is the same as above
+            # - otherwise we just check if the name provided is in the path and is
+            #   either the name of a folder or of a ruby file.
+            regex =
+              if file_to_instr.start_with?('/')
+                %r{\A#{Regexp.escape(file_to_instr)}(?:/|\.rb\z|\z)}
+              elsif file_to_instr.start_with?('./')
+                abs_path = File.expand_path(file_to_instr)
+                %r{\A#{Regexp.escape(abs_path)}(?:/|\.rb\z|\z)}
+              else
+                %r{/#{Regexp.escape(file_to_instr)}(?:/|\.rb\z|\z)}
+              end
+
+            add_instrumented_file(path) if path.match?(regex)
+          end
+        end
+      end
+
+      # Starts the TracePoints.
+      #
+      # Enables the script_compiled TracePoint if handled_errors_include is not empty.
+      def start
+        @handled_exc_tracker.enable
+        @include_path_getter&.enable
+      end
+
+      # Shuts down error tracker.
+      #
+      # Disables the TracePoints.
+      def shutdown!
+        @handled_exc_tracker.disable
+        @include_path_getter&.disable
+      end
+
+      private
+
+      # Generates a span event from the exception info.
+      #
+      # The event follows the otel semantics.
+      # https://opentelemetry.io/docs/specs/otel/trace/exceptions/
+      def generate_span_event(exception)
+        formatted_exception = Datadog::Core::Error.build_from(exception)
+        attributes = {
+          'exception.type' => formatted_exception.type,
+          'exception.message' => formatted_exception.message,
+          'exception.stacktrace' => formatted_exception.backtrace
+        }
+        Datadog::Tracing::SpanEvent.new('exception', attributes: attributes)
+      end
+
+      def add_instrumented_file(file_path)
+        @instrumented_files&.add(file_path)
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/configuration/settings.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../ext'
+
+module Datadog
+  module ErrorTracking
+    module Configuration
+      # Settings
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            # Error Tracking specific configurations.
+            # @public_api
+            settings :error_tracking do
+              # Enable automatic reporting of handled errors and defines the scope
+              # for which to report errors: user code, gems, or both. Possible
+              # values are: all | user | third_party.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors do |o|
+                o.type :string, nilable: true
+                o.default Ext::DEFAULT_HANDLED_ERRORS
+                o.env Ext::ENV_HANDLED_ERRORS
+                o.setter do |value|
+                  next value if Ext::VALID_HANDLED_ERRORS.include?(value)
+
+                  unless value.nil?
+                    Datadog.logger.warn(
+                      "Invalid handled errors scope: #{value}. " \
+                      "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
+                      'Deactivating the feature.'
+                    )
+                  end
+
+                  Ext::DEFAULT_HANDLED_ERRORS
+                end
+              end
+
+              # Enable automatic reporting of handled errors and specify what files should be
+              # instrumented. The value is a list of comma separated paths, filenames or gem names.
+              # The paths can be absolute, starting with '/' or relative to directory in which the program
+              # is launched, starting with './'.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS_MODULES' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors_include do |o|
+                o.type :array
+                o.default []
+                o.env Ext::ENV_HANDLED_ERRORS_INCLUDE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Configuration for ErrorTracking
+    module Configuration
+    end
+  end
+end
+
+require_relative 'configuration/settings'

data/lib/datadog/error_tracking/ext.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Error Tracking constants
+    module Ext
+      ENV_HANDLED_ERRORS = 'DD_ERROR_TRACKING_HANDLED_ERRORS'
+      ENV_HANDLED_ERRORS_INCLUDE = 'DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE'
+      HANDLED_ERRORS_ALL = 'all'
+      HANDLED_ERRORS_USER = 'user'
+      HANDLED_ERRORS_THIRD_PARTY = 'third_party'
+      DEFAULT_HANDLED_ERRORS = nil
+      VALID_HANDLED_ERRORS = [HANDLED_ERRORS_ALL, HANDLED_ERRORS_USER, HANDLED_ERRORS_THIRD_PARTY].freeze
+      SPAN_EVENTS_HAS_EXCEPTION = '_dd.span_events.has_exception'
+      RUBY_VERSION_WITH_RESCUE_EVENT = '3.3'
+    end
+  end
+end

data/lib/datadog/error_tracking/extensions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'configuration'
+require_relative '../core/configuration'
+
+module Datadog
+  module ErrorTracking
+    # Extends Datadog tracing with ErrorTracking features
+    module Extensions
+      # Inject Error Tracking into global objects.
+      def self.activate!
+        Core::Configuration::Settings.extend(Configuration::Settings)
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/filters.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Based on configuration, the TracePoint listening to :rescue or :raise
+    # may report more handled errors than we want to report. Therefore we need
+    # a function to filter the events. As the filter function both depends
+    # on configuration and is called numerous time, we generate it during
+    # during the initialization of the feature to have the best performance
+    # possible.
+    #
+    # @api private
+    module Filters
+      module_function
+
+      def get_gem_name(file_path)
+        regex = %r{gems/([^/]+)-\d}
+        regex_match = regex.match(file_path)
+        return unless regex_match
+
+        gem_name = regex_match[1]
+
+        begin
+          Gem::Specification.find_by_name(gem_name) # steep:ignore
+        rescue Gem::MissingSpecError
+          nil
+        end
+      end
+
+      def user_code?(file_path)
+        !get_gem_name(file_path)
+      end
+
+      def datadog_code?(file_path)
+        file_path.include?('lib/datadog/')
+      end
+
+      def third_party_code?(file_path)
+        gem_name = get_gem_name(file_path)
+        gem_name && gem_name != "datadog"
+      end
+
+      def file_included?(file_path, instrumented_files)
+        instrumented_files.include?(file_path)
+      end
+
+      # Generate the proc used in the TracePoint
+      def generate_filter(to_instrument_scope, handled_errors_include = nil)
+        case to_instrument_scope
+        # If DD_ERROR_TRACKING_HANDLED_ERRORS is set
+        when 'all'
+          proc { |file_path| !datadog_code?(file_path) }
+        when 'user'
+          # If DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
+          if handled_errors_include
+            proc { |file_path|
+              user_code?(file_path) || file_included?(file_path, handled_errors_include)
+            }
+          else
+            proc { |file_path| user_code?(file_path) }
+          end
+        when 'third_party'
+          if handled_errors_include
+            proc { |file_path|
+              third_party_code?(file_path) || file_included?(file_path, handled_errors_include)
+            }
+          else
+            proc { |file_path| third_party_code?(file_path) }
+          end
+        else
+          # If only DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
+          proc { |file_path| file_included?(file_path, handled_errors_include) }
+        end
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'error_tracking/collector'
+require_relative 'error_tracking/component'
+require_relative 'error_tracking/configuration'
+require_relative 'error_tracking/ext'
+require_relative 'error_tracking/extensions'
+require_relative 'error_tracking/filters'
+
+module Datadog
+  # Namespace for Datadog ErrorTracking.
+  #
+  # @api private
+  module ErrorTracking
+    # Expose ErrorTracking to global shared objects
+    Extensions.activate!
+  end
+end

data/lib/datadog/kit/appsec/events.rb

@@ -10,6 +10,7 @@ module Datadog
         LOGIN_SUCCESS_EVENT = 'users.login.success'
         LOGIN_FAILURE_EVENT = 'users.login.failure'
         SIGNUP_EVENT = 'users.signup'
+        USER_LOGIN_KEYS = ['usr.login', :'usr.login'].freeze
 
         class << self
           # Attach login success event information to the trace
@@ -30,11 +31,15 @@ module Datadog
             set_trace_and_span_context('track_login_success', trace, span) do |active_trace, active_span|
               user_options = user.dup
               user_id = user_options.delete(:id)
+              user_login = user_options[:login] || others[:'usr.login'] || others['usr.login'] || user_id
 
               raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
 
+              others = others.reject { |key, _| USER_LOGIN_KEYS.include?(key) }
+              others[:'usr.login'] = user_login
               track(LOGIN_SUCCESS_EVENT, active_trace, active_span, **others)
 
+              user_options[:login] = user_login
               Kit::Identity.set_user(active_trace, active_span, id: user_id, **user_options)
             end
           end
@@ -55,6 +60,7 @@ module Datadog
           #   event information to attach to the trace.
           def track_login_failure(trace = nil, span = nil, user_exists:, user_id: nil, **others)
             set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
+              others[:'usr.login'] = user_id if user_id && !others.key?(:'usr.login') && !others.key?('usr.login')
               track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
 
               active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id) if user_id
@@ -80,11 +86,15 @@ module Datadog
             set_trace_and_span_context('track_signup', trace, span) do |active_trace, active_span|
               user_options = user.dup
               user_id = user_options.delete(:id)
+              user_login = user_options[:login] || others[:'usr.login'] || others['usr.login'] || user_id
 
               raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
 
+              others = others.reject { |key, _| USER_LOGIN_KEYS.include?(key) }
+              others[:'usr.login'] = user_login
               track(SIGNUP_EVENT, active_trace, active_span, **others)
 
+              user_options[:login] = user_login
               Kit::Identity.set_user(trace, id: user_id, **user_options)
             end
           end
@@ -131,14 +141,16 @@ module Datadog
                 active_trace.keep!
               end
             end
+
+            ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', event)
           end
 
           private
 
           def set_trace_and_span_context(method, trace = nil, span = nil)
-            if (appsec_scope = Datadog::AppSec.active_scope)
-              trace = appsec_scope.trace
-              span = appsec_scope.service_entry_span
+            if (appsec_context = Datadog::AppSec.active_context)
+              trace = appsec_context.trace
+              span = appsec_context.span
             end
 
             trace ||= Datadog::Tracing.active_trace

data/lib/datadog/kit/identity.rb

@@ -33,6 +33,7 @@ module Datadog
         # @param others [Hash<Symbol, String>] Additional free-form
         #   user information to attach to the trace.
         #
+        # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
         def set_user(
@@ -66,21 +67,24 @@ module Datadog
               active_span.set_tag("usr.#{k}", v) unless v.nil?
             end
 
-            if Datadog::AppSec.active_scope
-              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
+            if Datadog::AppSec.active_context
+              active_span.set_tag('_dd.appsec.user.collection_mode', 'sdk')
+
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id, others[:login], session_id)
               ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
         # rubocop:enable Metrics/PerceivedComplexity
         # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
         def set_trace_and_span_context(method, trace = nil, span = nil)
-          if (appsec_scope = Datadog::AppSec.active_scope)
-            trace = appsec_scope.trace
-            span = appsec_scope.service_entry_span
+          if (appsec_context = Datadog::AppSec.active_context)
+            trace = appsec_context.trace
+            span = appsec_context.span
           end
 
           trace ||= Datadog::Tracing.active_trace

data/lib/datadog/opentelemetry/api/baggage.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'trace/span'
+require_relative '../../tracing/trace_operation'
+require_relative '../trace'
+
+module Datadog
+  module OpenTelemetry
+    module API
+      # The Baggage module provides an implementation of the OpenTelemetry Baggage API.
+      #
+      # Baggage is a set of name/value pairs describing user-defined properties that can be
+      # propagated through a distributed trace. This implementation follows the W3C Baggage
+      # specification and the OpenTelemetry Baggage API.
+      #
+      # @see https://www.w3.org/TR/baggage/
+      # @see https://opentelemetry.io/docs/specs/otel/baggage/api/
+      module Baggage
+        def initialize(trace: nil)
+          @trace = trace
+        end
+
+        # Returns a new context with empty baggage
+        #
+        # @param [optional Context] context Context to clear baggage from. Defaults
+        # to ::OpenTelemetry::Context.current
+        # @return [Context]
+        def clear(context: ::OpenTelemetry::Context.current)
+          context.ensure_trace.baggage.clear
+          context
+        end
+
+        # Returns the corresponding value for key
+        #
+        # @param [String] key The lookup key
+        # @param [optional Context] context The context from which to retrieve
+        # the key. Defaults to ::OpenTelemetry::Context.current
+        # @return [String, nil]
+        def value(key, context: ::OpenTelemetry::Context.current)
+          trace = context.ensure_trace
+          return nil if trace.nil?
+
+          trace.baggage && trace.baggage[key]
+        end
+
+        # Returns all baggage values
+        #
+        # @param [optional Context] context The context from which to retrieve
+        # the baggage. Defaults to ::OpenTelemetry::Context.current
+        # @return [Hash<String, String>]
+        def values(context: ::OpenTelemetry::Context.current)
+          trace = context.ensure_trace
+          return {} if trace.nil?
+
+          trace.baggage ? trace.baggage.dup : {}
+        end
+
+        # Returns a new context with new key-value pair
+        #
+        # @param [String] key The key to store this value under
+        # @param [String] value String value to be stored under key
+        # @param [optional String] metadata This is here to store properties
+        # received from other W3C Baggage implementations but is not exposed in
+        # OpenTelemetry. This is considered private API and not for use by
+        # end-users.
+        # @param [optional Context] context The context to update with new
+        # value. Defaults to ::OpenTelemetry::Context.current
+        # @return [Context]
+        def set_value(key, value, metadata: nil, context: ::OpenTelemetry::Context.current)
+          # Delegate to the context to set the value because an active trace is not guaranteed
+          # set_values handles this logic
+          context.set_values({ ::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY) => { key => value } })
+        end
+
+        # Returns a new context with value at key removed
+        #
+        # @param [String] key The key to remove
+        # @param [optional Context] context The context to remove baggage
+        # from. Defaults to ::OpenTelemetry::Context.current
+        # @return [Context]
+        def remove_value(key, context: ::OpenTelemetry::Context.current)
+          # Delegate to the context to remove the value because an active trace is not guaranteed
+          # set_values handles this logic
+          context.set_values({ Context::BAGGAGE_REMOVE_KEY => key })
+        end
+        ::OpenTelemetry::Baggage.singleton_class.prepend(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/api/baggage.rbs

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module API
+      module Baggage
+        def initialize: (?trace: Datadog::Tracing::TraceOperation?) -> void
+
+        # Returns a new context with empty baggage
+        def clear: (?context: OpenTelemetry::Context) -> OpenTelemetry::Context
+
+        # Returns the corresponding value for key
+        def value: (String key, ?context: OpenTelemetry::Context) -> String?
+
+        # Returns all baggage values
+        def values: (?context: OpenTelemetry::Context) -> Hash[String, String]
+
+        # Returns a new context with key-value pair
+        def set_value: (String key, String value, ?metadata: String?, ?context: OpenTelemetry::Context) -> OpenTelemetry::Context
+
+        # Returns a new context with value at key removed
+        def remove_value: (String key, ?context: OpenTelemetry::Context) -> OpenTelemetry::Context
+      end
+    end
+  end
+end 

data/lib/datadog/opentelemetry/api/context.rb

@@ -21,11 +21,13 @@ module Datadog
       module Context
         CURRENT_SPAN_KEY = ::OpenTelemetry::Trace.const_get(:CURRENT_SPAN_KEY)
         private_constant :CURRENT_SPAN_KEY
+        BAGGAGE_REMOVE_KEY = Object.new # sentinel object to indicate the deletion of a value in baggage
 
-        def initialize(entries, trace: nil)
+        def initialize(entries, trace: nil, baggage: nil)
           @trace = trace || ::Datadog::Tracing.send(:tracer).send(:start_trace)
           @trace.otel_values.merge!(entries) if entries
           @trace.otel_context ||= self
+          @trace.baggage = baggage if baggage
         end
 
         # Because Context can be reused, we have to make sure we have
@@ -79,8 +81,20 @@ module Datadog
           end
 
           existing_values = @trace && @trace.otel_values || {}
+          existing_baggage = @trace && @trace.baggage || {}
 
-          ::OpenTelemetry::Context.new(existing_values.merge(values), trace: trace)
+          # Retrieve the baggage removal sentinel and remove it from the values hash
+          existing_baggage.delete(values[BAGGAGE_REMOVE_KEY]) if values.key?(BAGGAGE_REMOVE_KEY)
+
+          # If the values hash contains a BAGGAGE_KEY, merge its contents with existing baggage
+          # Otherwise, keep the existing baggage unchanged
+          new_baggage = if values.key?(::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY))
+                          existing_baggage.merge(values[::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY)])
+                        else
+                          existing_baggage
+                        end
+
+          ::OpenTelemetry::Context.new(existing_values.merge(values), trace: trace, baggage: new_baggage)
         end
 
         # The Datadog {TraceOperation} associated with this {Context}.

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -45,7 +45,7 @@ module Datadog
         def add_attributes(attributes)
           res = super
           # Attributes can get dropped or their values truncated by `super`
-          attributes.each { |key, _| datadog_set_attribute(key) }
+          attributes.each_key { |key| datadog_set_attribute(key) }
           res
         end
 

data/lib/datadog/opentelemetry.rb

@@ -13,6 +13,7 @@ require_relative 'tracing'
 require_relative 'tracing/contrib'
 
 require_relative 'opentelemetry/api/context'
+require_relative 'opentelemetry/api/baggage'
 
 # DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`
 # DEV: and checks for compatibility?
@@ -29,7 +30,7 @@ module Datadog
 
     # Use `Datadog.logger` as the default logger
     def logger
-      @logger ||= ::Datadog.logger
+      ::Datadog.logger
     end
 
     ::OpenTelemetry.singleton_class.prepend(self)

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -42,7 +42,7 @@ module Datadog
         end
 
         def generate_json
-          JSON.fast_generate(v1: seen_libraries.to_a)
+          JSON.generate(v1: seen_libraries.to_a)
         end
 
         private