datadog-json_logger 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46efa4917f2fc960dac808402a47fe0f05bb3b7f99fbe110025bd8242450b44c
-  data.tar.gz: 70a463c19df71d259095a002e93a2d078a4cd042720a8ee271ff18326bd903ad
+  metadata.gz: 9df47f5fde7ef4639bbba0854c2d9fa90db7f580d489bfc04051c79c191c7d8f
+  data.tar.gz: 8f88db7cf3f19787fabb34d4fa95d787689223e8e933a9e38f3f448b2501322b
 SHA512:
-  metadata.gz: b76fb7fb03ecb2ef77fe8bcda47a231addb9c87705cd31c97f3f06ac5cdd74c85751ea5d23e7dc114ae59e3b0a4ac062f5501154f2dc7e987fef0fc6c0c6e960
-  data.tar.gz: 6b3ee3641cd0615e7a3ab8b5bcc3136eeed303c492ae95c7d5448f7d03a32e7818b231afe8ef39bdfee0814bf1d8ac87cd0eaed93671f038166971e4a8efcb36
+  metadata.gz: 24e9e6f6a59711c62bcc386be834a0b2e98bdc70e53084c7da73a6b04a26f25b091afae4a61b8049b6e24b5bc94901997b3383b8fa1d485033f09919140b5ac9
+  data.tar.gz: 8ad6344f4e503a946f6653a30840b9dca8afc70e161b5369a582dbcd2105b276f3545c66d396fb60ac6d25725745a6322c607336931a542f34915a3234652889

data/.rubocop.yml

@@ -2,6 +2,7 @@ AllCops:
   Exclude:
     - 'sig/**/*'
     - 'datadog-json_logger.gemspec'
+    - 'lib/datadog/tracing/contrib/bunny/patcher.rb'
     - 'vendor/**/*'
   NewCops: enable
   TargetRubyVersion: 3.0

data/README.md

@@ -4,27 +4,40 @@
 [![Rubocop and Rspec](https://github.com/buyco/datadog-json-logger/actions/workflows/main.yml/badge.svg)](https://github.com/buyco/datadog-json-logger/actions/workflows/main.yml)
 [![Publish on RubyGems](https://github.com/buyco/datadog-json-logger/actions/workflows/gem-push.yml/badge.svg)](https://github.com/buyco/datadog-json-logger/actions/workflows/gem-push.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.
+## Overview
 
-## Prerequisites
+`Datadog::JSONLogger` is a Ruby gem that provides seamless integration with Datadog's logging and tracing services. It formats logs as JSON with correlation IDs, making it easy to integrate with Datadog's log management and APM services.
 
-Before you begin, ensure you have [ddtrace](https://github.com/DataDog/dd-trace-rb) configured in your Ruby application, as `Datadog::JSONLogger` relies on `ddtrace` for tracing data.
+## Features
+
+| Feature                 | Description | Status |
+|-------------------------|-------------|---------|
+| JSON correlated logging | Formats logs as JSON with Datadog correlation IDs for better log analysis | ✅ |
+| Tracing                 | Integrates with Datadog APM for distributed tracing | ✅ |
+| Error Tracking          | Compatible with Datadog error tracking | ✅ |
+| Rack Middleware         | Provides a Rack middleware for HTTP request logging | ✅ |
+| Bunny Integration       | Adds tracing for RabbitMQ operations via Bunny | ✅ |
+
+## Requirements
+
+- Ruby 3.0+
+- [ddtrace](https://github.com/DataDog/dd-trace-rb) properly configured in your application
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add to your application's Gemfile:
 
 ```ruby
 gem 'datadog-json_logger'
 ```
 
-And then execute:
+And run:
 
 ```bash
 bundle install
 ```
 
-Or install it yourself as:
+Or install it directly:
 
 ```bash
 gem install datadog-json_logger
@@ -32,78 +45,178 @@ gem install datadog-json_logger
 
 ## Usage
 
-### JSONLogger
-
-`Datadog::JSONLogger` can be easily integrated into your Ruby application. Here's a quick example of how to use it in a Sinatra application:
+### Basic JSON Logger
 
 ```ruby
-# Example in Sinatra (app.rb)
 require 'datadog/json_logger'
 
+# Create a logger instance
+logger = Datadog::JSONLogger.new
+logger.info('Hello World')
+# => {"dd":{"trace_id":"0","span_id":"0","env":null,"service":"console","version":null},"timestamp":"2023-11-22 22:28:00 +0100","severity":"INFO ","progname":"","message":"Hello World"}
+```
+
+### Configuration
+
+```ruby
 Datadog::JSONLogger.configure do |config|
-  config.current_user = ->(env) { { email: env['warned'].user.email } } # Log user on each request
+  # Function to extract current user from environment
+  config.current_user = ->(env) { { email: env['current_user']&.email } }
+  
+  # Custom environment keys
   config.controller_key = "sinatra.controller_name"
-  config.resource_key   = "sinatra.resource_name"
-  config.action_key     = "sinatra.action_name"
+  config.resource_key = "sinatra.resource_name"
+  config.action_key = "sinatra.action_name"
+  
+  # Custom context for all logs
+  config.custom_context = -> { { environment: ENV['RACK_ENV'] } }
 end
+```
 
-def logger
-  @logger ||= Datadog::JSONLogger.new
+### With Rails
+
+In your `config/initializers/datadog.rb`:
+
+```ruby
+require 'datadog/json_logger'
+
+Datadog::JSONLogger.configure do |config|
+  config.current_user = ->(env) { { email: env['warden']&.user&.email } } 
+  config.controller_key = "action_controller.instance"
+  config.action_key = "action_dispatch.request.path_parameters[:action]"
+  config.resource_key = "action_dispatch.request.path_parameters[:controller]"
 end
 
-set :logger, logger
+# Configure Rails logger
+Rails.application.config.logger = Datadog::JSONLogger.new
+```
+
+### With Sinatra
+
+```ruby
+require 'datadog/json_logger'
+require 'datadog/rack_middleware'
 
-Sinatra::Application.logger.info("hello")
-# => {"dd":{"trace_id":"0","span_id":"0","env":null,"service":"console","version":null},"timestamp":"2023-11-22 22:28:00 +0100","severity":"INFO ","progname":"","message":"hello"}
+class MyApp < Sinatra::Base
+  configure do
+    # Configure Datadog logger
+    Datadog::JSONLogger.configure do |config|
+      config.current_user = ->(env) { { email: env['warden']&.user&.email } }
+    end
+    
+    # Set up logger
+    set :logger, Datadog::JSONLogger.new
+    
+    # Add Rack middleware
+    use Datadog::RackMiddleware, settings.logger
+  end
+  
+  # Your routes here
+end
 ```
 
-#### Add Custom Keys
-Create a custom formatter that inherits from `Datadog::Loggers::JSONFormatter` to add custom keys as shown below:
+### Custom Formatter
+
+Create a custom formatter to add more fields to your logs:
 
 ```ruby
 class CustomFormatter < Datadog::Loggers::JSONFormatter
   def self.call(severity, datetime, progname, msg)
     super do |log_hash|
-      log_hash[:my_custom_key] = "my_value"
-      log_hash[:my_custom_hash] = { key: "value" }
+      log_hash[:app_name] = "my_application"
+      log_hash[:environment] = ENV['RACK_ENV']
+      log_hash[:custom_field] = "custom value"
     end
   end
 end
 
-def logger
-  return @logger if @logger
-
-  @logger = Datadog::JSONLogger.new
-  @logger.progname = "my_app"
-  @logger.formatter = CustomFormatter
-  @logger
-end
-
-Sinatra::Application.logger.info("hello")
-# {"dd":{"trace_id":"0","span_id":"0","env":null,"service":"console","version":null},"timestamp":"2023-11-22 22:46:01 +0100","severity":"INFO ","progname":"my_app","message":"hello","my_custom_key":"my_value","my_custom_hash":{"key":"value"}}
+# Use the custom formatter
+logger = Datadog::JSONLogger.new
+logger.formatter = CustomFormatter
 ```
 
-### RackMiddleware
+### Rack Middleware
 
-`Datadog::RackMiddleware` formats Rack requests as JSON and disables the default textual stdout of `Rack::CommonLogger`:
+The `Datadog::RackMiddleware` logs HTTP requests in a structured format and disables the default `Rack::CommonLogger` output:
 
 ```ruby
-# Example in Sinatra (app.rb)
 require 'datadog/rack_middleware'
 
+# For Rack applications
 use Datadog::RackMiddleware, logger
 
-# Example in Rails (config.rb)
-config.middleware.use Datadog::RackMiddleware, config.logger
+# For Rails
+Rails.application.config.middleware.use Datadog::RackMiddleware, Rails.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) | ✅             |
+Sample output:
+
+```json
+{
+  "dd": {
+    "trace_id": "1234567890",
+    "span_id": "0987654321",
+    "env": "production",
+    "service": "my-service",
+    "version": "1.0.0"
+  },
+  "request": true,
+  "params": {"q": "search"},
+  "status": 200,
+  "format": "application/json",
+  "duration": 45,
+  "request_ip": "127.0.0.1",
+  "method": "GET",
+  "path": "/api/users",
+  "controller": "UsersController",
+  "action": "index",
+  "resource": "users",
+  "usr": {"email": "user@example.com"},
+  "message": "Received GET request from 127.0.0.1 at /api/users Responded with status 200 in 45ms."
+}
+```
+
+### Bunny Integration
 
+Trace RabbitMQ operations with the Bunny integration:
+
+```ruby
+require 'datadog/json_logger'
+
+# Configure Datadog tracing
+Datadog.configure do |c|
+  c.tracing.instrument :bunny, service_name: 'rabbitmq-service'
+  # Other Datadog configurations...
+end
+```
+
+#### End-to-End Tracing for Bunny Consumers
+
+For complete end-to-end tracing when consuming messages with Bunny, you need to manually continue the trace by using the helper in `lib/datadog/tracing/contrib/bunny/utils.rb`. Since the `on_delivery` method is a block, it's not possible to automatically retrieve trace information to continue the trace.
+
+```ruby
+require 'datadog/tracing/contrib/bunny/utils'
+
+# Use Bunny as normal
+bunny = Bunny.new
+bunny.start
+
+channel = bunny.create_channel
+queue = channel.queue("my_queue")
+
+# Publishing (automatically traced)
+channel.default_exchange.publish("Hello World!", routing_key: queue.name)
+
+# Consuming (automatically traced)
+queue.subscribe(block: true) do |delivery_info, properties, payload|
+  # Continue the trace from the producer
+  if properties.headers && properties.headers[:trace_digest]
+    Datadog::Tracing::Contrib::Bunny::Utils.continue_trace!(properties.headers[:trace_digest])
+  end
+
+  handle_message(payload)
+end
+```
 
 ## Development
 
@@ -127,4 +240,4 @@ This gem is available as open source under the terms of the [MIT License](https:
 
 ## Code of Conduct
 
-Everyone interacting in the Datadog::JSONLogger project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/buyco/datadog-json-logger/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Datadog::JSONLogger project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/buyco/datadog-json-logger/blob/main/CODE_OF_CONDUCT.md).

data/lib/datadog/loggers/version.rb

@@ -2,6 +2,6 @@
 
 module Datadog
   module Loggers
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end

data/lib/datadog/tracing/contrib/bunny/configuration/settings.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "datadog/tracing/contrib/configuration/settings"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Bunny
+        module Configuration
+          # Configuration settings for Bunny
+          class Settings < Contrib::Configuration::Settings
+            option :service_name, default: "bunny"
+            option :analytics_enabled, default: false
+            option :analytics_sample_rate, default: 1.0
+            option :distributed_tracing, default: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/bunny/ext.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Bunny
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          APP = "bunny"
+          ENV_ENABLED = "DD_TRACE_BUNNY_ENABLED"
+          ENV_SERVICE_NAME = "DD_TRACE_BUNNY_SERVICE_NAME"
+          ENV_ANALYTICS_ENABLED = "DD_TRACE_BUNNY_ANALYTICS_ENABLED"
+          ENV_ANALYTICS_SAMPLE_RATE = "DD_TRACE_BUNNY_ANALYTICS_SAMPLE_RATE"
+          SPAN_BASIC_PUBLISH = "bunny.publish"
+          SPAN_EXCHANGE_NAME = "bunny.exchange"
+          SPAN_EXCHANGE_PUBLISH = "bunny.exchange.publish"
+          SPAN_CONSUME = "bunny.consume"
+          SPAN_QUEUE_NAME = "bunny.queue"
+          SPAN_QUEUE_POP = "bunny.queue.pop"
+          SPAN_CHANNEL_ID = "bunny.channel.id"
+          TAG_MESSAGING_SYSTEM = "rabbitmq"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/bunny/integration.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "datadog/tracing/contrib"
+require "datadog/tracing/contrib/integration"
+require "datadog/tracing/contrib/bunny/configuration/settings"
+require "datadog/tracing/contrib/bunny/patcher"
+require "datadog/tracing/contrib/bunny/utils"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Bunny
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new("2.0.0")
+
+          register_as :bunny
+
+          def self.gem_name
+            "bunny"
+          end
+
+          def self.version
+            Gem.loaded_specs["bunny"]&.version
+          end
+
+          def self.loaded?
+            !defined?(::Bunny).nil?
+          end
+
+          def self.compatible?
+            super && version && version >= MINIMUM_VERSION
+          end
+
+          def auto_instrument?
+            false
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/bunny/patcher.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "datadog/tracing/contrib/patcher"
+require "datadog/tracing/contrib/bunny/ext"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Bunny
+        # Patcher for Bunny instrumentation
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::Bunny::Channel.prepend(ChannelPatch)
+            ::Bunny::Exchange.prepend(ExchangePatch)
+            ::Bunny::Queue.prepend(QueuePatch)
+            ::Bunny::Consumer.prepend(ConsumerPatch)
+          end
+
+          # Patch for Bunny::Channel
+          module ChannelPatch
+            def basic_consume(queue, consumer_tag = generate_consumer_tag, no_ack = false, exclusive = false,
+                              arguments = nil, &block)
+              config = Datadog.configuration.tracing[:bunny]
+              Datadog::Tracing.trace(Ext::SPAN_CONSUME, service: config.service_name) do |span|
+                span.type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::APP)
+                span.set_tag(Ext::SPAN_CHANNEL_ID, id)
+
+                super
+              end
+            end
+
+            def basic_publish(payload, exchange, routing_key, opts = {})
+              config = Datadog.configuration.tracing[:bunny]
+              Datadog::Tracing.trace(Ext::SPAN_BASIC_PUBLISH, service: config.service_name) do |span|
+                span.type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::APP)
+                span.set_tag(Ext::SPAN_CHANNEL_ID, id)
+
+                super
+              end
+            end
+          end
+
+          # Patch for Bunny::Exchange
+          module ExchangePatch
+            def publish(payload, opts = {})
+              config = Datadog.configuration.tracing[:bunny]
+              Datadog::Tracing.trace(Ext::SPAN_EXCHANGE_PUBLISH, service: config.service_name) do |span|
+                span.type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::APP)
+                span.set_tag(Ext::SPAN_EXCHANGE_NAME, name)
+
+                if (trace_digest = Datadog::Tracing.active_trace&.to_digest)
+                  opts[:trace_digest] ||= {}
+                  hash = JSON.parse(trace_digest.to_json)
+                  opts[:trace_digest].merge!(hash)
+                end
+                super
+              end
+            end
+          end
+
+          # Patch for Bunny::Queue
+          module QueuePatch
+            def pop(opts = { manual_ack: false }, &block)
+              config = Datadog.configuration.tracing[:bunny]
+              Datadog::Tracing.trace(Ext::SPAN_QUEUE_POP, service: config.service_name) do |span|
+                span.type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::APP)
+                span.set_tag(Ext::SPAN_QUEUE_NAME, name)
+
+                super
+              end
+            end
+          end
+
+          # Patch for Bunny::Consumer
+          module ConsumerPatch
+            def on_delivery(&block)
+              config = Datadog.configuration.tracing[:bunny]
+              Datadog::Tracing.trace(Ext::SPAN_CONSUME, service: config.service_name) do |span|
+                span.type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::APP)
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/bunny/utils.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Bunny
+        module Utils
+          module_function
+
+          # @param metadata [Hash, String]
+          # @return [void]
+          def continue_trace!(metadata)
+            serializes_trace_digest = if metadata.is_a?(Hash)
+                                        metadata.transform_keys(&:to_sym)
+                                      elsif metadata.is_a?(String)
+                                        JSON.parse(metadata, symbolize_names: true)
+                                      else
+                                        return
+                                      end
+
+            trace_digest = Datadog::Tracing::TraceDigest.new(**serializes_trace_digest)
+            return unless trace_digest
+
+            Datadog::Tracing.continue_trace!(trace_digest)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Datadog::Tracing::Contrib::Bunny::Utils.continue_trace!(metadata)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog-json_logger
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Eth3rnit3
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-10 00:00:00.000000000 Z
+date: 2025-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: datadog
@@ -49,6 +49,11 @@ files:
 - lib/datadog/loggers/json_formatter.rb
 - lib/datadog/loggers/version.rb
 - lib/datadog/rack_middleware.rb
+- lib/datadog/tracing/contrib/bunny/configuration/settings.rb
+- lib/datadog/tracing/contrib/bunny/ext.rb
+- lib/datadog/tracing/contrib/bunny/integration.rb
+- lib/datadog/tracing/contrib/bunny/patcher.rb
+- lib/datadog/tracing/contrib/bunny/utils.rb
 - nexus_release.sh
 - sig/.keep
 homepage: https://github.com/buyco/datadog-json-logger