Type Error, Random buffer, and Core

Steepfile

@@ -49,8 +49,6 @@ target :datadog do
   ignore 'lib/datadog/appsec/configuration/settings.rb'
   ignore 'lib/datadog/appsec/contrib/'
   ignore 'lib/datadog/appsec/monitor/gateway/watcher.rb'
-  ignore 'lib/datadog/core.rb'
-  ignore 'lib/datadog/core/buffer/random.rb'
   ignore 'lib/datadog/core/buffer/thread_safe.rb'
   ignore 'lib/datadog/core/configuration.rb'
   ignore 'lib/datadog/core/configuration/base.rb'
@@ -67,7 +65,6 @@ target :datadog do
   ignore 'lib/datadog/core/environment/socket.rb'
   ignore 'lib/datadog/core/environment/variable_helpers.rb'
   ignore 'lib/datadog/core/environment/vm_cache.rb'
-  ignore 'lib/datadog/core/error.rb'
   ignore 'lib/datadog/core/metrics/client.rb'
   ignore 'lib/datadog/core/metrics/helpers.rb'
   ignore 'lib/datadog/core/metrics/metric.rb'

lib/datadog/core/error.rb

@@ -11,12 +11,17 @@ class Error
       class << self
         def build_from(value)
           case value
-          when Error then value
-          when Array then new(*value)
+          # A Ruby {Exception} is the most common parameter type.
           when Exception then new(value.class, value.message, full_backtrace(value))
-          when ContainsMessage then new(value.class, value.message)
+          # steep:ignore:start
+          # Steep doesn't like an array with up to 3 elements to be passed here: it thinks the array is unbounded.
+          when Array then new(*value)
+          # Steep can follow the logic inside the lambda, thus it doesn't know `value` responds to `:message`.
+          when ->(v) { v.respond_to?(:message) } then new(value.class, value.message)
+          # steep:ignore:end
           when String then new(nil, value)
-          else BlankError
+          when Error then value
+          else Error.new # Blank error
           end
         end
 
@@ -75,7 +80,7 @@ def backtrace_for(ex, backtrace)
           if trace[1]
             # Ident stack trace for caller lines, to separate
             # them from the main error lines.
-            trace[1..-1].each do |line|
+            trace[1..-1]&.each do |line|
               backtrace << "\n\tfrom "
               backtrace << line
             end
@@ -92,9 +97,6 @@ def initialize(type = nil, message = nil, backtrace = nil)
         @message = Utils.utf8_encode(message)
         @backtrace = Utils.utf8_encode(backtrace)
       end
-
-      BlankError = Error.new
-      ContainsMessage = ->(v) { v.respond_to?(:message) }
     end
   end
 end

sig/datadog.rbs

@@ -0,0 +1,6 @@
+module Datadog
+  include Core::Configuration
+  include Core::Extensions
+  include Tracing::Contrib::Extensions::Configuration
+  include Tracing::Contrib::Extensions::Helpers
+end

sig/datadog/core/buffer/random.rbs

@@ -2,6 +2,37 @@ module Datadog
   module Core
     module Buffer
       class Random
+        @closed: bool
+        @items: Array[Object]
+        @max_size: Integer
+
+        def initialize: (Integer)-> void
+
+        def add!: (Object) -> Object
+
+        def add_all!: (Array[Object])-> void
+
+        def close: -> void
+
+        def closed?: -> bool
+
+        def concat: (Array[Object]) -> void
+
+        def drain!: -> Array[Object]
+
+        def empty?: -> bool
+
+        def full?: -> bool
+
+        def length: -> Integer
+
+        def overflow_segments: (Array[Object]) -> [Array[Object]?, Array[Object]?]
+
+        def pop: -> Array[Object]
+
+        def push: (Object) -> Object?
+
+        def replace!: (Object)-> Object?
       end
     end
   end

sig/datadog/core/configuration.rbs

@@ -8,6 +8,8 @@ module Datadog
       def logger: () -> Datadog::Core::Logger
 
       def configuration: () -> untyped # The DSL methods have to be explicitly declared for this to be typed
+
+      def shutdown!: -> void
     end
   end
 end

sig/datadog/core/error.rbs

@@ -1,25 +1,26 @@
 module Datadog
   module Core
     class Error
-      attr_reader type: untyped
+      attr_reader type: String
 
-      attr_reader message: untyped
+      attr_reader message: String
 
-      attr_reader backtrace: untyped
+      attr_reader backtrace: String
 
-      def self.build_from: (untyped value) -> untyped
+      interface _ContainsMessage
+        def message: () -> String
+        def class: () -> Class
+      end
+
+      def self.build_from: ((Error | [Object] | [Object, Object] | [Object, Object, Object] | ::Exception | _ContainsMessage | ::String) value) -> Error
 
       private
-      def self.full_backtrace: (untyped ex) -> untyped
-      def self.backtrace_for: (untyped ex, untyped backtrace) -> (nil | untyped)
+      def self.full_backtrace: (Exception ex) -> String
+      def self.backtrace_for: (Exception ex, String backtrace) -> void
 
       public
 
-      def initialize: (?untyped? `type`, ?untyped? message, ?untyped? backtrace) -> void
-
-      BlankError: untyped
-
-      ContainsMessage: untyped
+      def initialize: (?Object? `type`, ?Object? message, ?Object? backtrace) -> void
     end
   end
 end