datadog-json_logger 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c782c86a30a6c1fe054f28ac51fdf9880c3b93e1baef6a5f6ede2a303bfdc9af
-  data.tar.gz: fc5723c72b6e7f0d336f0a13ffb8bf72b0abc9191bfe1d5cc3322401e45248b7
+  metadata.gz: ba2bce053c01ef4787e60b782e1796f050d0d1462af869de7f09594a18bb1476
+  data.tar.gz: 980509d54903433e0a4e755c3a2d73e96a192ad8a732bf1c119dc675846f8563
 SHA512:
-  metadata.gz: 753436056b447ae7c563fed9bd003c549f67eac0977a4d9c2c4b1f1ac362addfa8aaae1108cd2d7e070c331dd9e6342dd7203aa19d0562fdeeb754537c0e82cc
-  data.tar.gz: cee0addc171cb32832ad02b0999bf09e3cf66cbcf9ad8b6cd4d024f24e905fd3f3b601157166bb40f5f29124461b224d44b1ce702114751799968a1cacbd4e5a
+  metadata.gz: 89da523671f52049de515a7299ab7f664d03925d777c16648de762859807c88f0fbdf3a20ed1ce438fcb4fdb9c6b459cf6674e7057a2daa62dadc65cde9b7580
+  data.tar.gz: e75b0d5ae7c83847ebd3aeca11611f05f11a5ac4ce7edfc7cb768e7fe4b91d6451d3d5dffd2f932faf38eb7985b8e8752419b0e09e1c8309caf55fcce826bacc

data/.rubocop.yml

@@ -1,4 +1,8 @@
 AllCops:
+  Exclude:
+    - 'sig/**/*'
+    - 'datadog-json_logger.gemspec'
+    - 'vendor/**/*'
   NewCops: enable
   TargetRubyVersion: 3.0
 

data/.rubycritic.yml

@@ -0,0 +1,4 @@
+minimum_score: 90
+paths:
+  - 'lib/'
+no_browser: true

data/README.md

@@ -1,6 +1,7 @@
 # Datadog::JSONLogger
 
 [![Rubocop and Rspec](https://github.com/Eth3rnit3/datadog-json_logger/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/Eth3rnit3/datadog-json_logger/actions/workflows/main.yml)
+[![Nexus upload](https://github.com/buyco/datadog-json-logger/actions/workflows/nexus.yml/badge.svg)](https://github.com/buyco/datadog-json-logger/actions/workflows/nexus.yml)
 
 `Datadog::JSONLogger` is a Ruby gem designed to seamlessly integrate Ruby applications with Datadog's logging and tracing services. This gem allows your Ruby application to format its output as JSON, including necessary correlation IDs and other details for optimal Datadog functionality.
 
@@ -85,6 +86,14 @@ require 'datadog/sinatra_middleware'
 use Datadog::SinatraMiddleware, logger
 ```
 
+## Features
+| Feature                 | Link                                            | Compatibility |
+|-------------------------|-------------------------------------------------|---------------|
+| JSON correlated logging | [Ruby Collection](https://docs.datadoghq.com/logs/log_collection/ruby/?tab=lograge) | ✅             |
+| Tracing                 | [Ruby Tracing application](https://docs.datadoghq.com/tracing/trace_collection/dd_libraries/ruby) | ✅             |
+| Error Tracking          | [Datadog error tracking](https://www.datadoghq.com/product/error-tracking) | ✅             |
+
+
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Steepfile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+
+  check "lib" # Directory name
+  # ignore "lib/templates/*.rb"
+
+  # library "pathname"              # Standard libraries
+  # library "strong_json"           # Gems
+  library "logger"
+  library "uri"
+  library "json"
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname"              # Standard libraries
+# end

data/datadog-json_logger.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email = ["eth3rnit3@gmail.com"]
 
   spec.summary = "Connect your ruby application to Datadog logging and tracing."
-  spec.description = "This gem provides easy integration for connecting a ruby application to Datadog's logging and tracing services." # rubocop:disable Layout/LineLength
+  spec.description = "This gem provides easy integration for connecting a ruby application to Datadog's logging and tracing services."
   spec.homepage = "https://github.com/eth3rnit3/datadog-json_logger"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.0"
@@ -22,17 +22,18 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+  spec.files =
+    Dir.chdir(__dir__) do
+      `git ls-files -z`.split("\x0").reject do |f|
+        (File.expand_path(f) == __FILE__) ||
+          f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+      end
     end
-  end
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "ddtrace", "~> 1.16.2"
+  spec.add_dependency("ddtrace", ">= 1.16")
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/datadog/json_logger.rb

@@ -1,17 +1,23 @@
 # frozen_string_literal: true
 
 require "logger"
-require_relative "loggers/version"
 require_relative "loggers/json_formatter"
+require_relative "loggers/version"
 
 module Datadog
   class Error < StandardError; end
 
   class JSONLogger < Logger
-    def initialize(output = nil)
-      $stdout.sync = true
-      super(output || $stdout)
+    def initialize(output = default_output)
+      super(output)
       @default_formatter = ::Datadog::Loggers::JSONFormatter
     end
+
+    private
+
+    def default_output
+      $stdout.sync = true
+      $stdout
+    end
   end
 end

data/lib/datadog/loggers/json_formatter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require "ddtrace"
-require "logger"
 require "json"
+require "logger"
 
 module Datadog
   module Loggers
@@ -14,7 +14,7 @@ module Datadog
 
         yield(log_hash) if block_given?
 
-        "#{log_hash.to_json}\r\n"
+        "#{::JSON.dump(log_hash)}\n"
       end
 
       def self.base_log_hash(severity, datetime, progname)
@@ -46,31 +46,42 @@ module Datadog
         }
       end
 
-      class HashFormatter
-        def self.format(log_hash, msg)
+      module HashFormatter
+        module_function
+
+        def format(log_hash, msg)
           log_hash.merge!(msg)
         end
       end
 
-      class ExceptionFormatter
-        def self.format(log_hash, exception)
+      module ExceptionFormatter
+        module_function
+
+        def format(log_hash, exception)
           log_hash.merge!(
-            exception: exception,
-            exception_message: exception.message,
-            exception_backtrace: exception.backtrace
+            message: exception.inspect,
+            error: {
+              kind: exception.class,
+              message: exception.message,
+              stack: (exception.backtrace || []).join("\n")
+            }
           )
         end
       end
 
-      class StringFormatter
-        def self.format(log_hash, msg)
+      module StringFormatter
+        module_function
+
+        def format(log_hash, msg)
           log_hash[:message] = msg.dup.force_encoding("utf-8")
         end
       end
 
-      class DefaultFormatter
-        def self.format(log_hash, msg)
-          log_hash[:message] = msg.to_s
+      module DefaultFormatter
+        module_function
+
+        def format(log_hash, msg)
+          log_hash[:message] = msg.is_a?(String) ? msg : msg.inspect
         end
       end
     end

data/lib/datadog/loggers/version.rb

@@ -2,6 +2,6 @@
 
 module Datadog
   module Loggers
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   end
 end

data/lib/datadog/sinatra_middleware.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "uri"
 require "json"
+require "uri"
 
 module Rack
   class CommonLogger
@@ -16,16 +16,21 @@ module Datadog
   class SinatraMiddleware
     attr_reader :app, :logger
 
-    def initialize(app, logger)
+    def initialize(app, logger, opt = {})
       @app = app
       @logger = logger
+      @raise_exceptions = opt.fetch(:raise_exceptions, false)
     end
 
     def call(env)
       request = Rack::Request.new(env)
       start_time = Time.now
 
-      status, headers, body = safely_process_request(env)
+      status, headers, body = if @raise_exceptions
+                                app.call(env)
+                              else
+                                safely_process_request(env)
+                              end
       end_time = Time.now
 
       log_request(request, env, status, headers, start_time, end_time)
@@ -39,8 +44,8 @@ module Datadog
 
     def safely_process_request(env)
       app.call(env)
-    rescue StandardError
-      [500, { "Content-Type" => "text/html" }, ["Internal Server Error"]]
+    rescue StandardError => e
+      [500, { "Content-Type": "application/json" }, [e.class.name, e.message].join(": ")]
     end
 
     def log_request(request, env, status, headers, start_time, end_time)
@@ -75,7 +80,7 @@ module Datadog
         exception_backtrace: exception.backtrace
       )
 
-      raise exception
+      raise(exception)
     end
   end
 end

data/sig/datadog/json_logger.rbs

@@ -1,6 +1,14 @@
 module Datadog
-  module JSONLogger
-    VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  class Error < StandardError
+  end
+
+  class JSONLogger < Logger
+    @default_formatter: singleton(Loggers::JSONFormatter)
+
+    def initialize: (?IO | StringIO | File | NilClass output) -> void
+
+    private
+
+    def default_output: () -> IO
   end
 end

data/sig/datadog/loggers/json_formatter.rbs

@@ -0,0 +1,29 @@
+module Datadog
+  module Loggers
+    class JSONFormatter < Logger::Formatter
+      def self.call: (String severity, DateTime datetime, String progname, untyped msg) ?{ (untyped) -> untyped } -> ::String
+
+      def self.base_log_hash: (String severity, DateTime datetime, String progname) -> { dd: Hash[untyped, untyped], timestamp: String, severity: String, progname: String }
+
+      def self.formatter_for: ((String | Hash[Symbol, untyped] | Exception) msg) -> untyped
+
+      def self.correlation_hash: () -> { trace_id: Integer, span_id: Integer, env: String, service: String, version: String | Integer }
+
+      module HashFormatter
+        def self?.format: (Hash[Symbol, untyped] log_hash, Hash[untyped, untyped] msg) -> untyped
+      end
+
+      module ExceptionFormatter
+        def self?.format: (Hash[Symbol, untyped] log_hash, Exception exception) -> untyped
+      end
+
+      module StringFormatter
+        def self?.format: (Hash[Symbol, untyped] log_hash, String msg) -> untyped
+      end
+
+      module DefaultFormatter
+        def self?.format: (Hash[Symbol, untyped] log_hash, untyped msg) -> untyped
+      end
+    end
+  end
+end

data/sig/datadog/loggers/version.rbs

@@ -0,0 +1,5 @@
+module Datadog
+  module Loggers
+    VERSION: String
+  end
+end

data/sig/datadog/sinatra_middleware.rbs

@@ -0,0 +1,32 @@
+module Rack
+  class CommonLogger
+    def log: (untyped _env, untyped _status, untyped _response_headers, untyped _began_at) -> nil
+  end
+end
+
+module Datadog
+  class SinatraMiddleware
+    @app: untyped
+    @logger: Logger
+    @raise_exceptions: bool
+
+    attr_reader app: untyped
+    attr_reader logger: Logger
+
+    def initialize: (untyped app, Logger logger, ?Hash[Symbol, untyped] opt) -> void
+
+    def call: (untyped env) -> untyped
+
+    private
+
+    def safely_process_request: (untyped env) -> untyped
+
+    def log_request: (Rack::Request request, untyped env, String status, Hash[String, String] headers, Time start_time, Time end_time) -> untyped
+
+    def calculate_duration: (Time start_time, Time end_time) -> Integer
+
+    def parse_query: (String query_string) -> Hash[String, String]
+
+    def handle_exception: (Exception exception) -> Exception
+  end
+end

data/sig/datadog/tracing.rbs

@@ -0,0 +1,90 @@
+module Datadog
+  # Datadog APM tracing public API.
+  #
+  # The Datadog team ensures that public methods in this module
+  # only receive backwards compatible changes, and breaking changes
+  # will only occur in new major versions releases.
+  # @public_api
+  module Tracing
+    # (see Datadog::Tracing::Tracer#trace)
+    # @public_api
+    def self.trace: (untyped name, ?continue_from: untyped?, **untyped span_options) { () -> untyped } -> untyped
+
+    # (see Datadog::Tracing::Tracer#continue_trace!)
+    # @public_api
+    def self.continue_trace!: (untyped digest) { () -> untyped } -> untyped
+
+    # The tracer's internal logger instance.
+    # All tracing log output is handled by this object.
+    #
+    # The logger can be configured through {.configure},
+    # through {Datadog::Core::Configuration::Settings::DSL::Logger} options.
+    #
+    # @!attribute [r] logger
+    # @public_api
+    def self.logger: () -> untyped
+
+    # (see Datadog::Tracing::Tracer#active_trace)
+    # @public_api
+    def self.active_trace: () -> (nil | untyped)
+
+    # (see Datadog::Tracing::Tracer#active_span)
+    # @public_api
+    def self.active_span: () -> (nil | untyped)
+
+    # (see Datadog::Tracing::TraceSegment#keep!)
+    # If no trace is active, no action is taken.
+    # @public_api
+    def self.keep!: () -> untyped
+
+    # (see Datadog::Tracing::TraceSegment#reject!)
+    # If no trace is active, no action is taken.
+    # @public_api
+    def self.reject!: () -> untyped
+
+    # (see Datadog::Tracing::Tracer#active_correlation)
+    # @public_api
+    def self.correlation: () -> (nil | untyped)
+
+    # Textual representation of {.correlation}, which can be
+    # added to individual log lines in order to correlate them with the active
+    # trace.
+    #
+    # Example:
+    #
+    # ```
+    # MyLogger.log("#{Datadog::Tracing.log_correlation}] My message")
+    # # dd.env=prod dd.service=auth dd.version=13.8 dd.trace_id=5458478252992251 dd.span_id=7117552347370098 My message
+    # ```
+    #
+    # @return [String] correlation information
+    # @public_api
+    def self.log_correlation: () -> untyped
+
+    # Gracefully shuts down the tracer.
+    #
+    # The public tracing API will still respond to method calls as usual
+    # but might not internally perform the expected internal work after shutdown.
+    #
+    # This avoids errors being raised across the host application
+    # during shutdown while allowing for the graceful decommission of resources.
+    #
+    # {.shutdown!} cannot be reversed.
+    # @public_api
+    def self.shutdown!: () -> (nil | untyped)
+
+    # (see Datadog::Tracing::Pipeline.before_flush)
+    def self.before_flush: (*untyped processors) { () -> untyped } -> untyped
+
+    # Is the tracer collecting telemetry data in this process?
+    # @return [Boolean] `true` if the tracer is collecting data in this process, otherwise `false`.
+    def self.enabled?: () -> (false | untyped)
+
+    private
+
+    # DEV: components hosts both tracing and profiling inner objects today
+    def self.components: () -> untyped
+
+    def self.tracer: () -> untyped
+  end
+end

data/sig/rack/request.rbs

@@ -0,0 +1,362 @@
+module Rack
+  class Request
+    self.@forwarded_priority: untyped
+
+    self.@x_forwarded_proto_priority: untyped
+
+    @env: untyped
+
+    @params: untyped
+
+    attr_accessor self.ip_filter: untyped
+
+    # The priority when checking forwarded headers. The default
+    # is <tt>[:forwarded, :x_forwarded]</tt>, which means, check the
+    # +Forwarded+ header first, followed by the appropriate
+    # <tt>X-Forwarded-*</tt> header.  You can revert the priority by
+    # reversing the priority, or remove checking of either
+    # or both headers by removing elements from the array.
+    #
+    # This should be set as appropriate in your environment
+    # based on what reverse proxies are in use.  If you are not
+    # using reverse proxies, you should probably use an empty
+    # array.
+    attr_accessor self.forwarded_priority: untyped
+
+    # The priority when checking either the <tt>X-Forwarded-Proto</tt>
+    # or <tt>X-Forwarded-Scheme</tt> header for the forwarded protocol.
+    # The default is <tt>[:proto, :scheme]</tt>, to try the
+    # <tt>X-Forwarded-Proto</tt> header before the
+    # <tt>X-Forwarded-Scheme</tt> header.  Rack 2 had behavior
+    # similar to <tt>[:scheme, :proto]</tt>.  You can remove either or
+    # both of the entries in array to ignore that respective header.
+    attr_accessor self.x_forwarded_proto_priority: untyped
+
+    ALLOWED_SCHEMES: ::Array["https" | "http" | "wss" | "ws"]
+
+    def initialize: (untyped env) -> void
+
+    def params: () -> untyped
+
+    def update_param: (untyped k, untyped v) -> untyped
+
+    def delete_param: (untyped k) -> untyped
+
+    module Env
+      @env: untyped
+
+      # The environment of the request.
+      attr_reader env: untyped
+
+      def initialize: (untyped env) -> void
+
+      # Predicate method to test to see if `name` has been set as request
+      # specific data
+      def has_header?: (untyped name) -> untyped
+
+      # Get a request specific value for `name`.
+      def get_header: (untyped name) -> untyped
+
+      # If a block is given, it yields to the block if the value hasn't been set
+      # on the request.
+      def fetch_header: (untyped name) { () -> untyped } -> untyped
+
+      # Loops through each key / value pair in the request specific data.
+      def each_header: () { () -> untyped } -> untyped
+
+      # Set a request specific value for `name` to `v`
+      def set_header: (untyped name, untyped v) -> untyped
+
+      # Add a header that may have multiple values.
+      #
+      # Example:
+      #   request.add_header 'Accept', 'image/png'
+      #   request.add_header 'Accept', '*/*'
+      #
+      #   assert_equal 'image/png,*/*', request.get_header('Accept')
+      #
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+      def add_header: (untyped key, untyped v) -> untyped
+
+      # Delete a request specific value for `name`.
+      def delete_header: (untyped name) -> untyped
+
+      def initialize_copy: (untyped other) -> untyped
+    end
+
+    module Helpers
+      # The set of form-data media-types. Requests that do not indicate
+      # one of the media types present in this list will not be eligible
+      # for form-data / param parsing.
+      FORM_DATA_MEDIA_TYPES: ::Array["application/x-www-form-urlencoded" | "multipart/form-data"]
+
+      # The set of media-types. Requests that do not indicate
+      # one of the media types present in this list will not be eligible
+      # for param parsing like soap attachments or generic multiparts
+      PARSEABLE_DATA_MEDIA_TYPES: ::Array["multipart/related" | "multipart/mixed"]
+
+      # Default ports depending on scheme. Used to decide whether or not
+      # to include the port in a generated URI.
+      DEFAULT_PORTS: ::Hash[::String, 80 | 443]
+
+      # The address of the client which connected to the proxy.
+      HTTP_X_FORWARDED_FOR: "HTTP_X_FORWARDED_FOR"
+
+      # The contents of the host/:authority header sent to the proxy.
+      HTTP_X_FORWARDED_HOST: "HTTP_X_FORWARDED_HOST"
+
+      HTTP_FORWARDED: "HTTP_FORWARDED"
+
+      # The value of the scheme sent to the proxy.
+      HTTP_X_FORWARDED_SCHEME: "HTTP_X_FORWARDED_SCHEME"
+
+      # The protocol used to connect to the proxy.
+      HTTP_X_FORWARDED_PROTO: "HTTP_X_FORWARDED_PROTO"
+
+      # The port used to connect to the proxy.
+      HTTP_X_FORWARDED_PORT: "HTTP_X_FORWARDED_PORT"
+
+      # Another way for specifying https scheme was used.
+      HTTP_X_FORWARDED_SSL: "HTTP_X_FORWARDED_SSL"
+
+      def body: () -> untyped
+
+      def script_name: () -> untyped
+
+      def script_name=: (untyped s) -> untyped
+
+      def path_info: () -> untyped
+
+      def path_info=: (untyped s) -> untyped
+
+      def request_method: () -> untyped
+
+      def query_string: () -> untyped
+
+      def content_length: () -> untyped
+
+      def logger: () -> untyped
+
+      def user_agent: () -> untyped
+
+      # the referer of the client
+      def referer: () -> untyped
+
+      alias referrer referer
+
+      def session: () -> untyped
+
+      def session_options: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type DELETE
+      def delete?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type GET
+      def get?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type HEAD
+      def head?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type OPTIONS
+      def options?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type LINK
+      def link?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type PATCH
+      def patch?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type POST
+      def post?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type PUT
+      def put?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type TRACE
+      def trace?: () -> untyped
+
+      # Checks the HTTP request method (or verb) to see if it was of type UNLINK
+      def unlink?: () -> untyped
+
+      def scheme: () -> ("https" | "https" | untyped)
+
+      # The authority of the incoming request as defined by RFC3976.
+      # https://tools.ietf.org/html/rfc3986#section-3.2
+      #
+      # In HTTP/1, this is the `host` header.
+      # In HTTP/2, this is the `:authority` pseudo-header.
+      def authority: () -> untyped
+
+      # The authority as defined by the `SERVER_NAME` and `SERVER_PORT`
+      # variables.
+      def server_authority: () -> (nil | untyped)
+
+      def server_name: () -> untyped
+
+      def server_port: () -> untyped
+
+      def cookies: () -> untyped
+
+      def content_type: () -> untyped
+
+      def xhr?: () -> untyped
+
+      # The `HTTP_HOST` header.
+      def host_authority: () -> untyped
+
+      def host_with_port: (?untyped authority) -> untyped
+
+      # Returns a formatted host, suitable for being used in a URI.
+      def host: () -> untyped
+
+      # Returns an address suitable for being to resolve to an address.
+      # In the case of a domain name or IPv4 address, the result is the same
+      # as +host+. In the case of IPv6 or future address formats, the square
+      # brackets are removed.
+      def hostname: () -> untyped
+
+      def port: () -> untyped
+
+      def forwarded_for: () -> (untyped | nil)
+
+      def forwarded_port: () -> (untyped | nil)
+
+      def forwarded_authority: () -> (untyped | nil)
+
+      def ssl?: () -> untyped
+
+      def ip: () -> untyped
+
+      # The media type (type/subtype) portion of the CONTENT_TYPE header
+      # without any media type parameters. e.g., when CONTENT_TYPE is
+      # "text/plain;charset=utf-8", the media-type is "text/plain".
+      #
+      # For more information on the use of media types in HTTP, see:
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
+      def media_type: () -> untyped
+
+      # The media type parameters provided in CONTENT_TYPE as a Hash, or
+      # an empty Hash if no CONTENT_TYPE or media-type parameters were
+      # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
+      # this method responds with the following Hash:
+      #   { 'charset' => 'utf-8' }
+      def media_type_params: () -> untyped
+
+      # The character set of the request body if a "charset" media type
+      # parameter was given, or nil if no "charset" was specified. Note
+      # that, per RFC2616, text/* media types that specify no explicit
+      # charset are to be considered ISO-8859-1.
+      def content_charset: () -> untyped
+
+      # Determine whether the request body contains form-data by checking
+      # the request content-type for one of the media-types:
+      # "application/x-www-form-urlencoded" or "multipart/form-data". The
+      # list of form-data media types can be modified through the
+      # +FORM_DATA_MEDIA_TYPES+ array.
+      #
+      # A request body is also assumed to contain form-data when no
+      # content-type header is provided and the request_method is POST.
+      def form_data?: () -> untyped
+
+      # Determine whether the request body contains data by checking
+      # the request media_type against registered parse-data media-types
+      def parseable_data?: () -> untyped
+
+      # Returns the data received in the query string.
+      def GET: () -> untyped
+
+      # Returns the data received in the request body.
+      #
+      # This method support both application/x-www-form-urlencoded and
+      # multipart/form-data.
+      def POST: () -> untyped
+
+      # The union of GET and POST data.
+      #
+      # Note that modifications will not be persisted in the env. Use update_param or delete_param if you want to destructively modify params.
+      def params: () -> untyped
+
+      # Destructively update a parameter, whether it's in GET and/or POST. Returns nil.
+      #
+      # The parameter is updated wherever it was previous defined, so GET, POST, or both. If it wasn't previously defined, it's inserted into GET.
+      #
+      # <tt>env['rack.input']</tt> is not touched.
+      def update_param: (untyped k, untyped v) -> (nil | untyped)
+
+      # Destructively delete a parameter, whether it's in GET or POST. Returns the value of the deleted parameter.
+      #
+      # If the parameter is in both GET and POST, the POST value takes precedence since that's how #params works.
+      #
+      # <tt>env['rack.input']</tt> is not touched.
+      def delete_param: (untyped k) -> untyped
+
+      def base_url: () -> ::String
+
+      # Tries to return a remake of the original request URL as a string.
+      def url: () -> untyped
+
+      def path: () -> untyped
+
+      def fullpath: () -> (untyped | ::String)
+
+      def accept_encoding: () -> untyped
+
+      def accept_language: () -> untyped
+
+      def trusted_proxy?: (untyped ip) -> untyped
+
+      # shortcut for <tt>request.params[key]</tt>
+      def []: (untyped key) -> untyped
+
+      # shortcut for <tt>request.params[key] = value</tt>
+      #
+      # Note that modifications will not be persisted in the env. Use update_param or delete_param if you want to destructively modify params.
+      def []=: (untyped key, untyped value) -> untyped
+
+      # like Hash#values_at
+      def values_at: (*untyped keys) -> untyped
+
+      private
+
+      def default_session: () -> ::Hash[untyped, untyped]
+
+      # Assist with compatibility when processing `X-Forwarded-For`.
+      def wrap_ipv6: (untyped host) -> (::String | untyped)
+
+      def parse_http_accept_header: (untyped header) -> untyped
+
+      # Get an array of values set in the RFC 7239 `Forwarded` request header.
+      def get_http_forwarded: (untyped token) -> untyped
+
+      def query_parser: () -> untyped
+
+      def parse_query: (untyped qs, ?::String d) -> untyped
+
+      def parse_multipart: () -> untyped
+
+      def expand_param_pairs: (untyped pairs, ?untyped query_parser) -> untyped
+
+      def split_header: (untyped value) -> (untyped | ::Array[untyped])
+
+      AUTHORITY: ::Regexp
+
+      def split_authority: (untyped authority) -> ::Array[untyped]
+
+      def reject_trusted_ip_addresses: (untyped ip_addresses) -> untyped
+
+      FORWARDED_SCHEME_HEADERS: { proto: untyped, scheme: untyped }
+
+      def forwarded_scheme: () -> (untyped | nil)
+
+      def allowed_scheme: (untyped header) -> (untyped | nil)
+
+      def forwarded_priority: () -> untyped
+
+      def x_forwarded_proto_priority: () -> untyped
+    end
+
+    include Env
+
+    include Helpers
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog-json_logger
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Eth3rnit3
@@ -14,16 +14,16 @@ dependencies:
   name: ddtrace
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.2
+        version: '1.16'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.2
+        version: '1.16'
 description: This gem provides easy integration for connecting a ruby application
   to Datadog's logging and tracing services.
 email:
@@ -35,12 +35,14 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
+- ".rubycritic.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Dockerfile.nexus
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - datadog-json_logger.gemspec
 - lib/datadog/json_logger.rb
 - lib/datadog/loggers/json_formatter.rb
@@ -48,6 +50,11 @@ files:
 - lib/datadog/sinatra_middleware.rb
 - nexus_release.sh
 - sig/datadog/json_logger.rbs
+- sig/datadog/loggers/json_formatter.rbs
+- sig/datadog/loggers/version.rbs
+- sig/datadog/sinatra_middleware.rbs
+- sig/datadog/tracing.rbs
+- sig/rack/request.rbs
 homepage: https://github.com/eth3rnit3/datadog-json_logger
 licenses:
 - MIT