datadog-ci 0.2.0 → 0.4.0

data/lib/datadog/ci/transport/api/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../ext/transport"
+
+module Datadog
+  module CI
+    module Transport
+      module Api
+        class Base
+          attr_reader :http
+
+          def initialize(http:)
+            @http = http
+          end
+
+          def request(path:, payload:, verb: "post")
+            http.request(
+              path: path,
+              payload: payload,
+              verb: verb,
+              headers: headers
+            )
+          end
+
+          private
+
+          def headers
+            {
+              Ext::Transport::HEADER_CONTENT_TYPE => Ext::Transport::CONTENT_TYPE_MESSAGEPACK
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/transport/api/builder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "ci_test_cycle"
+require_relative "evp_proxy"
+require_relative "../http"
+require_relative "../../ext/transport"
+
+module Datadog
+  module CI
+    module Transport
+      module Api
+        module Builder
+          def self.build_ci_test_cycle_api(settings)
+            dd_site = settings.site || Ext::Transport::DEFAULT_DD_SITE
+            url = settings.ci.agentless_url ||
+              "https://#{Ext::Transport::TEST_VISIBILITY_INTAKE_HOST_PREFIX}.#{dd_site}:443"
+
+            uri = URI.parse(url)
+            raise "Invalid agentless mode URL: #{url}" if uri.host.nil?
+
+            http = Datadog::CI::Transport::HTTP.new(
+              host: uri.host,
+              port: uri.port,
+              ssl: uri.scheme == "https" || uri.port == 443,
+              compress: true
+            )
+
+            CiTestCycle.new(api_key: settings.api_key, http: http)
+          end
+
+          def self.build_evp_proxy_api(agent_settings)
+            http = Datadog::CI::Transport::HTTP.new(
+              host: agent_settings.hostname,
+              port: agent_settings.port,
+              ssl: agent_settings.ssl,
+              timeout: agent_settings.timeout_seconds,
+              compress: false
+            )
+
+            EvpProxy.new(http: http)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/transport/api/ci_test_cycle.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../ext/transport"
+
+module Datadog
+  module CI
+    module Transport
+      module Api
+        class CiTestCycle < Base
+          attr_reader :api_key
+
+          def initialize(api_key:, http:)
+            @api_key = api_key
+
+            super(http: http)
+          end
+
+          private
+
+          def headers
+            headers = super
+            headers[Ext::Transport::HEADER_DD_API_KEY] = api_key
+            headers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/transport/api/evp_proxy.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "datadog/core/environment/container"
+
+require_relative "base"
+require_relative "../../ext/transport"
+
+module Datadog
+  module CI
+    module Transport
+      module Api
+        class EvpProxy < Base
+          def request(path:, payload:, verb: "post")
+            path = "#{Ext::Transport::EVP_PROXY_PATH_PREFIX}#{path.sub(/^\//, "")}"
+
+            super(
+              path: path,
+              payload: payload,
+              verb: verb
+            )
+          end
+
+          private
+
+          def container_id
+            return @container_id if defined?(@container_id)
+
+            @container_id = Datadog::Core::Environment::Container.container_id
+          end
+
+          def headers
+            headers = super
+            headers[Ext::Transport::HEADER_EVP_SUBDOMAIN] = Ext::Transport::TEST_VISIBILITY_INTAKE_HOST_PREFIX
+
+            c_id = container_id
+            headers[Ext::Transport::HEADER_CONTAINER_ID] = c_id unless c_id.nil?
+
+            headers
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,9 +10,11 @@ module Datadog
         module_function
 
         def compress(input)
-          gzip_writer = Zlib::GzipWriter.new(StringIO.new)
+          sio = StringIO.new
+          gzip_writer = Zlib::GzipWriter.new(sio, Zlib::DEFAULT_COMPRESSION, Zlib::DEFAULT_STRATEGY)
           gzip_writer << input
-          gzip_writer.close.string
+          gzip_writer.close
+          sio.string
         end
       end
     end

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

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require "net/http"
+require "delegate"
+require "datadog/core/transport/http/adapters/net"
+require "datadog/core/transport/http/env"
+require "datadog/core/transport/request"
 
 require_relative "gzip"
 require_relative "../ext/transport"
@@ -26,126 +29,47 @@ module Datadog
           @compress = compress.nil? ? false : compress
         end
 
-        def request(path:, payload:, headers:, method: "post")
-          raise "Unknown method #{method}" unless respond_to?(method, true)
-
+        def request(path:, payload:, headers:, verb: "post")
           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}; " \
+            "Sending #{verb} 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)
+          ResponseDecorator.new(
+            adapter.call(
+              build_env(path: path, payload: payload, headers: headers, verb: verb)
+            )
+          )
         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)
+        def build_env(path:, payload:, headers:, verb:)
+          env = Datadog::Core::Transport::HTTP::Env.new(
+            Datadog::Core::Transport::Request.new
+          )
+          env.body = payload
+          env.path = path
+          env.headers = headers
+          env.verb = verb
+          env
         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)
+        def adapter
+          @adapter ||= Datadog::Core::Transport::HTTP::Adapters::Net.new(host, port, timeout: timeout, ssl: ssl)
         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
-
+        # this is needed because Datadog::Tracing::Writer is not fully compatiple with Datadog::Core::Transport
+        # TODO: remove before 1.0 when CI implements its own worker
+        class ResponseDecorator < ::SimpleDelegator
           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

data/lib/datadog/ci/utils/url.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Utils
+      module Url
+        def self.filter_sensitive_info(url)
+          return nil if url.nil?
+
+          url.gsub(%r{((https?|ssh)://)[^/]*@}, '\1')
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/version.rb

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

data/lib/datadog/ci.rb

@@ -5,11 +5,200 @@ require_relative "ci/version"
 require "datadog/core"
 
 module Datadog
-  # Namespace for Datadog CI instrumentation:
-  # e.g. rspec, cucumber, etc...
+  # Datadog CI visibility public API.
+  #
+  # @public_api
   module CI
-    class Error < StandardError; end
-    # Your code goes here...
+    class << self
+      # Return a {Datadog::CI::Test ci_test} that will trace a test called `test_name`.
+      # Raises an error if a test is already active.
+      #
+      # You could trace your test using a <tt>do-block</tt> like:
+      #
+      # ```
+      # Datadog::CI.trace_test(
+      #   "test_add_two_numbers",
+      #   service_name: "my-web-site-tests",
+      #   operation_name: "test",
+      #   tags: { Datadog::CI::Ext::Test::TAG_FRAMEWORK => "my-test-framework" }
+      # ) do |ci_test|
+      #   result = run_test
+      #
+      #   if result.ok?
+      #     ci_test.passed!
+      #   else
+      #     ci_test.failed!(exception: result.exception)
+      #   end
+      # end
+      # ```
+      #
+      # The {#trace_test} method can also be used without a block in this way:
+      # ```
+      # ci_test = Datadog::CI.trace_test(
+      #   "test_add_two_numbers',
+      #   service: "my-web-site-tests",
+      #   operation_name: "test",
+      #   tags: { Datadog::CI::Ext::Test::TAG_FRAMEWORK => "my-test-framework" }
+      # )
+      # run_test
+      # ci_test.finish
+      # ```
+      #
+      # Remember that in this case, calling {Datadog::CI::Test#finish} is mandatory.
+      #
+      # @param [String] test_name {Datadog::CI::Test} name (example: "test_add_two_numbers").
+      # @param [String] operation_name defines label for a test span in trace view ("test" if it's missing)
+      # @param [String] service_name the service name for this test
+      # @param [Hash<String,String>] tags extra tags which should be added to the test.
+      # @return [Object] If a block is provided, returns the result of the block execution.
+      # @return [Datadog::CI::Test] If no block is provided, returns the active,
+      #         unfinished {Datadog::CI::Test}.
+      # @yield Optional block where new newly created {Datadog::CI::Test} captures the execution.
+      # @yieldparam [Datadog::CI::Test] ci_test the newly created and active [Datadog::CI::Test]
+      #
+      # @public_api
+      def trace_test(test_name, service_name: nil, operation_name: "test", tags: {}, &block)
+        recorder.trace_test(test_name, service_name: service_name, operation_name: operation_name, tags: tags, &block)
+      end
+
+      # Same as {#trace_test} but it does not accept a block.
+      # Raises an error if a test is already active.
+      #
+      # Usage:
+      #
+      # ```
+      # ci_test = Datadog::CI.start_test(
+      #   "test_add_two_numbers',
+      #   service: "my-web-site-tests",
+      #   operation_name: "test",
+      #   tags: { Datadog::CI::Ext::Test::TAG_FRAMEWORK => "my-test-framework" }
+      # )
+      # run_test
+      # ci_test.finish
+      # ```
+      #
+      # @param [String] test_name {Datadog::CI::Test} name (example: "test_add_two_numbers").
+      # @param [String] operation_name the resource this span refers, or `test` if it's missing
+      # @param [String] service_name the service name for this span.
+      # @param [Hash<String,String>] tags extra tags which should be added to the test.
+      # @return [Datadog::CI::Test] Returns the active, unfinished {Datadog::CI::Test}.
+      #
+      # @public_api
+      def start_test(test_name, service_name: nil, operation_name: "test", tags: {})
+        recorder.trace_test(test_name, service_name: service_name, operation_name: operation_name, tags: tags)
+      end
+
+      # Trace any custom span inside a test. For example, you could trace:
+      # - cucumber step
+      # - database query
+      # - any custom operation you want to see in your trace view
+      #
+      # You can use thi method with a <tt>do-block</tt> like:
+      #
+      # ```
+      # Datadog::CI.trace(
+      #   "step",
+      #   "Given I have 42 cucumbers",
+      #   tags: {}
+      # ) do
+      #   run_operation
+      # end
+      # ```
+      #
+      # The {#trace} method can also be used without a block in this way:
+      # ```
+      # ci_span = Datadog::CI.trace(
+      #   "step",
+      #   "Given I have 42 cucumbers",
+      #   tags: {}
+      # )
+      # run_test
+      # ci_span.finish
+      # ```
+      # Remember that in this case, calling {Datadog::CI::Span#finish} is mandatory.
+      #
+      # @param [String] span_type custom, user-defined span type (for example "step" or "query").
+      # @param [String] span_name the resource this span refers, or `test` if it's missing
+      # @param [Hash<String,String>] tags extra tags which should be added to the span.
+      # @return [Object] If a block is provided, returns the result of the block execution.
+      # @return [Datadog::CI::Span] If no block is provided, returns the active,
+      #         unfinished {Datadog::CI::Span}.
+      # @yield Optional block where new newly created {Datadog::CI::Span} captures the execution.
+      # @yieldparam [Datadog::CI::Span] ci_span the newly created and active [Datadog::CI::Span]
+      #
+      # @public_api
+      def trace(span_type, span_name, tags: {}, &block)
+        recorder.trace(span_type, span_name, tags: tags, &block)
+      end
+
+      # The active, unfinished custom span if it matches given type.
+      # If no span is active, or if the active span is not a custom span with given type, returns nil.
+      #
+      # The active span belongs to an {.active_test}.
+      #
+      # Usage:
+      #
+      # ```
+      # # start span
+      # Datadog::CI.trace(
+      #   "step",
+      #   "Given I have 42 cucumbers",
+      #   tags: {}
+      # )
+      #
+      # # somewhere else, access the active "step" span
+      # step_span = Datadog::CI.active_span("step")
+      # step_span.finish()
+      # ```
+      #
+      # @param [String] span_type type of the span to retrieve (for example "step" or "query") that was provided to {.trace}
+      # @return [Datadog::CI::Span] the active span
+      # @return [nil] if no span is active, or if the active span is not a custom span with given type
+      def active_span(span_type)
+        span = recorder.active_span
+        span if span && span.span_type == span_type
+      end
+
+      # The active, unfinished test span.
+      #
+      # Usage:
+      #
+      # ```
+      # # start a test
+      # Datadog::CI.start_test(
+      #   "test_add_two_numbers',
+      #   service: "my-web-site-tests",
+      #   operation_name: "test",
+      #   tags: { Datadog::CI::Ext::Test::TAG_FRAMEWORK => "my-test-framework" }
+      # )
+      #
+      # # somewhere else, access the active test
+      # test_span = Datadog::CI.active_test
+      # test_span.passed!
+      # test_span.finish
+      # ```
+      #
+      # @return [Datadog::CI::Test] the active test
+      # @return [nil] if no test is active
+      def active_test
+        recorder.active_test
+      end
+
+      # Internal only, to finish a test use Datadog::CI::Test#finish
+      def deactivate_test(test)
+        recorder.deactivate_test(test)
+      end
+
+      private
+
+      def components
+        Datadog.send(:components)
+      end
+
+      def recorder
+        components.ci_recorder
+      end
+    end
   end
 end
 

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

@@ -2,11 +2,17 @@ module Datadog
   module CI
     module Configuration
       module Components : Datadog::Core::Configuration::Components
+        @ci_recorder: Datadog::CI::Recorder
+
+        attr_reader ci_recorder: Datadog::CI::Recorder
+
         def initialize: (untyped settings) -> void
 
         def activate_ci!: (untyped settings) -> untyped
 
-        def build_agentless_transport: (untyped settings) -> Datadog::CI::TestVisibility::Transport
+        def build_agentless_transport: (untyped settings) -> Datadog::CI::TestVisibility::Transport?
+        def build_evp_proxy_transport: (untyped settings, untyped agent_settings) -> Datadog::CI::TestVisibility::Transport
+        def can_use_evp_proxy?: (untyped settings, untyped agent_settings) -> bool
       end
     end
   end

data/sig/datadog/ci/context/local.rbs

@@ -0,0 +1,21 @@
+module Datadog
+  module CI
+    module Context
+      class Local
+        @key: Symbol
+
+        def initialize: () -> void
+
+        def activate_test!: (Datadog::CI::Test test) ?{ () -> untyped } -> void
+
+        def deactivate_test!: (Datadog::CI::Test test) -> void
+
+        def active_test: () -> Datadog::CI::Test?
+
+        private
+
+        def active_test=: (Datadog::CI::Test? test) -> untyped
+      end
+    end
+  end
+end

data/sig/datadog/ci/ext/environment/extractor.rbs

@@ -18,8 +18,6 @@ module Datadog
           def normalize_git!: () -> void
 
           def expand_workspace!: () -> void
-
-          def filter_sensitive_info: (String? url) -> String?
         end
       end
     end

data/sig/datadog/ci/ext/environment/providers/aws_code_pipeline.rbs

@@ -0,0 +1,19 @@
+module Datadog
+  module CI
+    module Ext
+      module Environment
+        module Providers
+          class AwsCodePipeline < Base
+            def self.handles?: (Hash[String, String?] env) -> bool
+
+            def provider_name: () -> "awscodepipeline"
+
+            def pipeline_id: () -> String?
+
+            def ci_env_vars: () -> String?
+          end
+        end
+      end
+    end
+  end
+end

data/sig/datadog/ci/ext/environment/providers/base.rbs

@@ -8,6 +8,8 @@ module Datadog
             @branch: String?
             @tag: String?
 
+            def self.handles?: (Hash[String, String?] env) -> bool
+
             def initialize: (Hash[String, String?] env) -> void
 
             def job_name: () -> nil

data/sig/datadog/ci/ext/environment/providers/github_actions.rbs

@@ -5,6 +5,7 @@ module Datadog
         module Providers
           class GithubActions < Extractor
             @ref: String
+            @github_server_url: String?
 
             def provider_name: () -> "github"
 
@@ -29,6 +30,10 @@ module Datadog
             def git_branch_or_tag: () -> String?
 
             def ci_env_vars: () -> String?
+
+            private
+
+            def github_server_url: () -> String?
           end
         end
       end

data/sig/datadog/ci/ext/environment/providers.rbs

@@ -3,7 +3,7 @@ module Datadog
     module Ext
       module Environment
         module Providers
-          PROVIDERS: ::Array[[String, untyped]]
+          PROVIDERS: ::Array[untyped]
 
           def self.for_environment: (Hash[String, String?] env) -> Providers::Base
         end