datadog-ci 0.1.0 → 0.2.0

data/lib/datadog/ci/transport/http.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+require_relative "gzip"
+require_relative "../ext/transport"
+
+module Datadog
+  module CI
+    module Transport
+      class HTTP
+        attr_reader \
+          :host,
+          :port,
+          :ssl,
+          :timeout,
+          :compress
+
+        DEFAULT_TIMEOUT = 30
+
+        def initialize(host:, timeout: DEFAULT_TIMEOUT, port: nil, ssl: true, compress: false)
+          @host = host
+          @port = port
+          @timeout = timeout
+          @ssl = ssl.nil? ? true : ssl
+          @compress = compress.nil? ? false : compress
+        end
+
+        def request(path:, payload:, headers:, method: "post")
+          raise "Unknown method #{method}" unless respond_to?(method, true)
+
+          if compress
+            headers[Ext::Transport::HEADER_CONTENT_ENCODING] = Ext::Transport::CONTENT_ENCODING_GZIP
+            payload = Gzip.compress(payload)
+          end
+
+          Datadog.logger.debug do
+            "Sending #{method} request: host=#{host}; port=#{port}; ssl_enabled=#{ssl}; " \
+              "compression_enabled=#{compress}; path=#{path}; payload_size=#{payload.size}"
+          end
+
+          send(method, path: path, payload: payload, headers: headers)
+        end
+
+        private
+
+        def open(&block)
+          req = ::Net::HTTP.new(@host, @port)
+
+          req.use_ssl = @ssl
+          req.open_timeout = req.read_timeout = @timeout
+
+          req.start(&block)
+        end
+
+        def post(path:, headers:, payload:)
+          post = ::Net::HTTP::Post.new(path, headers)
+          post.body = payload
+
+          http_response = open do |http|
+            http.request(post)
+          end
+
+          Response.new(http_response)
+        rescue => e
+          Datadog.logger.debug("Unable to send events: #{e}")
+
+          InternalErrorResponse.new(e)
+        end
+
+        # Data structure for an HTTP Response
+        class Response
+          attr_reader :http_response
+
+          def initialize(http_response)
+            @http_response = http_response
+          end
+
+          def payload
+            http_response.body
+          end
+
+          def code
+            http_response.code.to_i
+          end
+
+          def ok?
+            code.between?(200, 299)
+          end
+
+          def unsupported?
+            code == 415
+          end
+
+          def not_found?
+            code == 404
+          end
+
+          def client_error?
+            code.between?(400, 499)
+          end
+
+          def server_error?
+            code.between?(500, 599)
+          end
+
+          def internal_error?
+            false
+          end
+
+          def trace_count
+            0
+          end
+
+          def inspect
+            "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
+            "not_found?:#{not_found?}, client_error?:#{client_error?}, " \
+            "server_error?:#{server_error?}, internal_error?:#{internal_error?}, " \
+            "payload:#{payload}"
+          end
+        end
+
+        class InternalErrorResponse < Response
+          class DummyNetHTTPResponse
+            def body
+              ""
+            end
+
+            def code
+              "-1"
+            end
+          end
+
+          attr_reader :error
+
+          def initialize(error)
+            super(DummyNetHTTPResponse.new)
+
+            @error = error
+          end
+
+          def internal_error?
+            true
+          end
+
+          def inspect
+            "#{super}, error_class:#{error.class}, error:#{error}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/version.rb

@@ -4,7 +4,7 @@ module Datadog
   module CI
     module VERSION
       MAJOR = "0"
-      MINOR = "1"
+      MINOR = "2"
       PATCH = "0"
       PRE = nil
       BUILD = nil

data/lib/datadog/ci.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "ddtrace"
 require_relative "ci/version"
 
 require "datadog/core"

data/sig/datadog/ci/configuration/components.rbs

@@ -5,6 +5,8 @@ module Datadog
         def initialize: (untyped settings) -> void
 
         def activate_ci!: (untyped settings) -> untyped
+
+        def build_agentless_transport: (untyped settings) -> Datadog::CI::TestVisibility::Transport
       end
     end
   end

data/sig/datadog/ci/configuration/settings.rbs

@@ -3,6 +3,8 @@ module Datadog
     module Configuration
       module Settings
         extend Datadog::Core::Configuration::Options::ClassMethods
+        include Datadog::Core::Configuration::Options::InstanceMethods
+
         extend Datadog::Core::Configuration::Base::ClassMethods
 
         def self.extended: (untyped base) -> untyped

data/sig/datadog/ci/contrib/cucumber/configuration/settings.rbs

@@ -3,7 +3,7 @@ module Datadog
     module Contrib
       module Cucumber
         module Configuration
-          class Settings < Datadog::Tracing::Contrib::Configuration::Settings
+          class Settings < Datadog::CI::Contrib::Settings
           end
         end
       end

data/sig/datadog/ci/contrib/cucumber/integration.rbs

@@ -3,7 +3,8 @@ module Datadog
     module Contrib
       module Cucumber
         class Integration
-          extend Datadog::Tracing::Contrib::Integration
+          extend Datadog::CI::Contrib::Integration::ClassMethods
+          include Datadog::CI::Contrib::Integration::InstanceMethods
 
           MINIMUM_VERSION: Gem::Version
 

data/sig/datadog/ci/contrib/integration.rbs

@@ -0,0 +1,44 @@
+module Datadog
+  module CI
+    module Contrib
+      module Integration
+        self.@registry: Hash[Symbol, untyped]
+
+        def self.included: (Module base) -> void
+
+        def self.register: (untyped integration, Symbol name) -> void
+
+        def self.registry: () -> Hash[Symbol, Struct[untyped]]
+
+        module ClassMethods
+          def register_as: (Symbol name) -> void
+
+          def version: () -> Gem::Version?
+
+          def available?: () -> bool
+
+          def loaded?: () -> bool
+
+          def compatible?: () -> bool
+
+          def patchable?: () -> bool
+        end
+
+        module InstanceMethods
+          extend ClassMethods
+          @configuration: Datadog::CI::Contrib::Settings?
+
+          def configuration: () -> Datadog::CI::Contrib::Settings
+
+          def configure: (?::Hash[Symbol, untyped] options) ?{ (Datadog::CI::Contrib::Settings) -> Datadog::CI::Contrib::Settings } -> Datadog::CI::Contrib::Settings
+
+          def reset_configuration!: () -> void
+
+          def patcher: () -> Datadog::Tracing::Contrib::Patcher?
+
+          def new_configuration: () -> Datadog::CI::Contrib::Settings
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/contrib/minitest/configuration/settings.rbs

@@ -3,7 +3,7 @@ module Datadog
     module Contrib
       module Minitest
         module Configuration
-          class Settings < Datadog::Tracing::Contrib::Configuration::Settings
+          class Settings < Datadog::CI::Contrib::Settings
           end
         end
       end

data/sig/datadog/ci/contrib/minitest/integration.rbs

@@ -3,13 +3,14 @@ module Datadog
     module Contrib
       module Minitest
         class Integration
-          extend Datadog::Tracing::Contrib::Integration
+          extend Datadog::CI::Contrib::Integration::ClassMethods
+          include Datadog::CI::Contrib::Integration::InstanceMethods
 
-          MINIMUM_VERSION: untyped
+          MINIMUM_VERSION: Gem::Version
 
           def self.version: () -> untyped
 
-          def self.loaded?: () -> untyped
+          def self.loaded?: () -> bool
 
           def compatible?: () -> bool
 

data/sig/datadog/ci/contrib/rspec/configuration/settings.rbs

@@ -3,7 +3,7 @@ module Datadog
     module Contrib
       module RSpec
         module Configuration
-          class Settings < Datadog::Tracing::Contrib::Configuration::Settings
+          class Settings < Datadog::CI::Contrib::Settings
           end
         end
       end

data/sig/datadog/ci/contrib/rspec/integration.rbs

@@ -3,9 +3,10 @@ module Datadog
     module Contrib
       module RSpec
         class Integration
-          extend Datadog::Tracing::Contrib::Integration
+          extend Datadog::CI::Contrib::Integration::ClassMethods
+          include Datadog::CI::Contrib::Integration::InstanceMethods
 
-          MINIMUM_VERSION: untyped
+          MINIMUM_VERSION: Gem::Version
 
           def self.version: () -> untyped
 

data/sig/datadog/ci/contrib/settings.rbs

@@ -0,0 +1,25 @@
+module Datadog
+  module CI
+    module Contrib
+      class Settings
+        include Core::Configuration::Base
+        extend Datadog::Core::Configuration::Options::ClassMethods
+        include Datadog::Core::Configuration::Options::InstanceMethods
+
+        extend Datadog::Core::Configuration::Base::ClassMethods
+
+        def configure: (?::Hash[Symbol, untyped] options) ?{ (Datadog::CI::Contrib::Settings) -> Datadog::CI::Contrib::Settings } -> Datadog::CI::Contrib::Settings?
+
+        def []: (Symbol name) -> Datadog::CI::Contrib::Settings
+
+        def []=: (untyped name, untyped value) -> untyped
+
+        # default configuration options
+        #
+        def enabled: () -> bool
+        def service_name: () -> String
+        def operation_name: () -> String
+      end
+    end
+  end
+end

data/sig/datadog/ci/ext/settings.rbs

@@ -3,6 +3,8 @@ module Datadog
     module Ext
       module Settings
         ENV_MODE_ENABLED: String
+        ENV_AGENTLESS_MODE_ENABLED: String
+        ENV_AGENTLESS_URL: String
       end
     end
   end

data/sig/datadog/ci/ext/transport.rbs

@@ -0,0 +1,21 @@
+module Datadog
+  module CI
+    module Ext
+      module Transport
+        HEADER_DD_API_KEY: "DD-API-KEY"
+
+        HEADER_CONTENT_TYPE: "Content-Type"
+
+        HEADER_CONTENT_ENCODING: "Content-Encoding"
+
+        TEST_VISIBILITY_INTAKE_HOST_PREFIX: "citestcycle-intake"
+
+        TEST_VISIBILITY_INTAKE_PATH: "/api/v2/citestcycle"
+
+        CONTENT_TYPE_MESSAGEPACK: "application/msgpack"
+
+        CONTENT_ENCODING_GZIP: "gzip"
+      end
+    end
+  end
+end

data/sig/datadog/ci/{test.rbs → recorder.rbs}

@@ -1,6 +1,6 @@
 module Datadog
   module CI
-    module Test
+    module Recorder
       self.@environment_tags: Hash[String, String]
 
       def self.trace: (untyped span_name, ?::Hash[untyped, untyped] options) ?{ (untyped, untyped) -> untyped } -> untyped

data/sig/datadog/ci/test_visibility/flush.rbs

@@ -0,0 +1,17 @@
+module Datadog
+  module CI
+    module TestVisibility
+      module Flush
+        module Tagging
+          def get_trace: (Datadog::Tracing::TraceOperation trace_op) -> untyped
+        end
+        class Finished < Tracing::Flush::Finished
+          prepend Tagging
+        end
+        class Partial < Tracing::Flush::Partial
+          prepend Tagging
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/test_visibility/serializers/base.rbs

@@ -0,0 +1,73 @@
+module Datadog
+  module CI
+    module TestVisibility
+      module Serializers
+        class Base
+          MINIMUM_TIMESTAMP_NANO: 946684800000000000
+          MINIMUM_DURATION_NANO: 0
+          MAXIMUM_DURATION_NANO: 9223372036854775807
+
+          @content_fields_count: Integer
+          @start: Integer
+          @duration: Integer
+
+          attr_reader trace: Datadog::Tracing::TraceSegment
+          attr_reader span: Datadog::Tracing::Span
+
+          def initialize: (Datadog::Tracing::TraceSegment trace, Datadog::Tracing::Span span) -> void
+
+          def to_msgpack: (?untyped? packer) -> untyped
+
+          def valid?: () -> bool
+          def content_fields: () -> ::Array[String | Hash[String, String]]
+          def content_map_size: () -> Integer
+
+          def runtime_id: () -> String
+
+          def trace_id: () -> String
+
+          def span_id: () -> String
+
+          def parent_id: () -> String
+
+          def type: () -> nil
+
+          def version: () -> 1
+
+          def span_type: () -> String
+
+          def name: () -> String
+
+          def resource: () -> String
+
+          def service: () -> String
+
+          def start: () -> Integer
+
+          def duration: () -> Integer
+
+          def meta: () -> Hash[String, untyped]
+
+          def metrics: () -> Hash[String, untyped]
+
+          def error: () -> Integer
+
+          def self.calculate_content_map_size: (Array[String | Hash[String, String]] fields_list) -> Integer
+
+          private
+
+          def valid_start_time?: () -> bool
+          def valid_duration?: () -> bool
+          def required_fields_present?: () -> bool
+          def required_fields: () -> Array[String]
+
+          def write_field: (untyped packer, String field_name, ?String? method) -> untyped
+          def time_nano: (Time time) -> Integer
+          def duration_nano: (Float duration) -> Integer
+
+          def content_fields_count: () -> Integer
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/test_visibility/serializers/factories/test_level.rbs

@@ -0,0 +1,13 @@
+module Datadog
+  module CI
+    module TestVisibility
+      module Serializers
+        module Factories
+          module TestLevel
+            def self?.serializer: (Datadog::Tracing::TraceSegment trace, Datadog::Tracing::Span span) -> Datadog::CI::TestVisibility::Serializers::Base
+          end
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/test_visibility/serializers/span.rbs

@@ -0,0 +1,18 @@
+module Datadog
+  module CI
+    module TestVisibility
+      module Serializers
+        class Span < Base
+          CONTENT_FIELDS: Array[String | Hash[String, String]]
+          CONTENT_MAP_SIZE: Integer
+          REQUIRED_FIELDS: Array[String]
+
+          def required_fields: () -> Array[String]
+          def content_fields: () -> Array[String | Hash[String, String]]
+          def content_map_size: () -> Integer
+          def type: () -> "span"
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/test_visibility/serializers/test_v1.rbs

@@ -0,0 +1,23 @@
+module Datadog
+  module CI
+    module TestVisibility
+      module Serializers
+        class TestV1 < Base
+          CONTENT_FIELDS: Array[String | Hash[String, String]]
+          CONTENT_MAP_SIZE: Integer
+          REQUIRED_FIELDS: Array[String]
+
+          def required_fields: () -> Array[String]
+          def content_fields: () -> Array[String | Hash[String, String]]
+          def content_map_size: () -> Integer
+
+          def type: () -> "test"
+
+          def name: () -> ::String
+
+          def resource: () -> ::String
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/test_visibility/transport.rbs

@@ -0,0 +1,39 @@
+module Datadog
+  module CI
+    module TestVisibility
+      class Transport
+        DEFAULT_MAX_PAYLOAD_SIZE: Integer
+
+        attr_reader serializers_factory: singleton(Datadog::CI::TestVisibility::Serializers::Factories::TestLevel)
+        attr_reader api_key: String
+        attr_reader env: String?
+        attr_reader http: Datadog::CI::Transport::HTTP
+        attr_reader max_payload_size: Integer
+
+        @api_key: String
+        @env: String?
+        @http: Datadog::CI::Transport::HTTP
+        @serializers_factory: singleton(Datadog::CI::TestVisibility::Serializers::Factories::TestLevel)
+        @max_payload_size: Integer
+
+        def initialize: (
+          api_key: String,
+          url: ::String,
+          ?env: ::String?,
+          ?serializers_factory: singleton(Datadog::CI::TestVisibility::Serializers::Factories::TestLevel),
+          ?max_payload_size: Integer
+        ) -> void
+
+        def send_traces: (Array[Datadog::Tracing::TraceSegment] traces) -> ::Array[Datadog::CI::Transport::HTTP::Response]
+
+        private
+
+        def send_payload: (String encoded_payload) -> Datadog::CI::Transport::HTTP::Response
+        def pack_events: (Array[String] encoded_events) -> String
+        def encode_traces: (Array[Datadog::Tracing::TraceSegment] traces) -> ::Array[String]
+        def encode_span: (Datadog::Tracing::TraceSegment trace, Datadog::Tracing::Span span) -> String?
+        def encoder: () -> singleton(Datadog::Core::Encoding::MsgpackEncoder)
+      end
+    end
+  end
+end

data/sig/datadog/ci/transport/gzip.rbs

@@ -0,0 +1,9 @@
+module Datadog
+  module CI
+    module Transport
+      module Gzip
+        def self?.compress: (String input) -> String
+      end
+    end
+  end
+end

data/sig/datadog/ci/transport/http.rbs

@@ -0,0 +1,61 @@
+module Datadog
+  module CI
+    module Transport
+      class HTTP
+        attr_reader host: String
+        attr_reader port: Integer?
+        attr_reader ssl: bool
+        attr_reader timeout: Integer
+        attr_reader compress: bool
+
+        DEFAULT_TIMEOUT: 30
+
+        def initialize: (host: String, ?port: Integer?, ?ssl: bool, ?timeout: Integer, ?compress: bool) -> void
+
+        def request: (?method: String, payload: String, headers: Hash[String, String], path: String) -> Response
+
+        private
+
+        def open: () { (::Net::HTTP) -> Net::HTTPResponse } -> Net::HTTPResponse
+
+        def post: (payload: String, headers: Hash[String, String], path: String) -> Response
+
+        class Response
+          attr_reader http_response: (Net::HTTPResponse | InternalErrorResponse::DummyNetHTTPResponse)
+
+          def initialize: ((Net::HTTPResponse | InternalErrorResponse::DummyNetHTTPResponse) http_response) -> void
+
+          def payload: () -> String
+
+          def code: () -> Integer
+
+          def ok?: () -> bool
+
+          def unsupported?: () -> bool
+
+          def not_found?: () -> bool
+
+          def client_error?: () -> bool
+
+          def server_error?: () -> bool
+
+          def internal_error?: () -> bool
+
+          def inspect: () -> ::String
+        end
+
+        class InternalErrorResponse < Response
+          class DummyNetHTTPResponse
+            def body: () -> ""
+            def code: () -> "-1"
+          end
+
+          attr_reader error: StandardError
+          @error: StandardError
+
+          def initialize: (StandardError error) -> void
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/version.rbs

@@ -1,16 +1,16 @@
 module Datadog
   module CI
     module VERSION
-      MAJOR: "0"
-      MINOR: "1"
-      PATCH: "0"
+      MAJOR: String
+      MINOR: String
+      PATCH: String
       PRE: String?
       BUILD: String?
 
       STRING: String
 
-      MINIMUM_RUBY_VERSION: "2.1.0"
-      MAXIMUM_RUBY_VERSION: "3.4"
+      MINIMUM_RUBY_VERSION: String
+      MAXIMUM_RUBY_VERSION: String
     end
   end
 end