lumberjack_data_dog 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 746fb699cb9f259ed561b070a1a3939573c052a2354cc7edbe7bf2b72084cf1e
+  data.tar.gz: 0647be2db0eac1df4c77ef89e5859396cd345a5b1291419a8ece171aff3bd48a
+SHA512:
+  metadata.gz: 6232d656b9202c58b504c8eeb1a1904dbb85d06ed3d80d2e302d7cd0fd4657b2874685d3396e4b777ded9f7cd180fd1ddbbd1b192e78be0a160ac32b3806b4ce
+  data.tar.gz: '01209a5f00a204706e100cb6d389f5fac1b46f0ebe5ab39b12558c32811cf727813d5a1fe9b810599cd43d93b51182354a089e7de70e9d8312157c55b8aa7daf'

data/.github/dependabot.yml

@@ -0,0 +1,12 @@
+# Dependabot update strategy
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: weekly
+    allow:
+      # Automatically keep all runtime dependencies updated
+      - dependency-name: "*"
+        dependency-type: "production"
+    versioning-strategy: lockfile-only

data/.github/workflows/continuous_integration.yml

@@ -0,0 +1,46 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - master
+      - actions-*
+    tags:
+      - v*
+  pull_request:
+    branches-ignore:
+      - actions-*
+  workflow_dispatch:
+
+env:
+  BUNDLE_CLEAN: "true"
+  BUNDLE_PATH: vendor/bundle
+  BUNDLE_JOBS: 3
+  BUNDLE_RETRY: 3
+
+jobs:
+  build:
+    name: ${{ matrix.ruby }} build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - ruby: "ruby"
+            standardrb: true
+          - ruby: "3.0"
+          - ruby: "2.7"
+          - ruby: "2.5"
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby}}
+    - name: Install gems
+      run: |
+        bundle install
+    - name: Run Tests
+      run: bundle exec rake
+    - name: standardrb
+      if: matrix.standardrb
+      run:  bundle exec standardrb

data/.standard.yml

@@ -0,0 +1,8 @@
+ruby_version: 2.5
+
+format: progress
+
+ignore:
+  - 'spec/**/*':
+    - Lint/UselessAssignment
+    - Lint/Void

data/CHANGE_LOG.md

@@ -0,0 +1,11 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.0.0
+
+### Added
+
+- Initial release

data/MIT_LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2025 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+# Lumberjack DataDog
+
+[![Continuous Integration](https://github.com/bdurand/lumberjack_data_dog/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/lumberjack_data_dog/actions/workflows/continuous_integration.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/lumberjack_data_dog.svg)](https://badge.fury.io/rb/lumberjack_data_dog)
+
+This gem provides a logging setup for using the [lumberjack](https://github.com/bdurand/lumberjack) gem with DataDog. It sets up JSON logging and maps values to DataDog's [standard attributes](https://docs.datadoghq.com/logs/processing/attributes_naming_convention/).
+
+## Features
+
+- **DataDog Standard Attribute Mapping**: Automatically maps Lumberjack log fields to DataDog's standard attributes:
+  - `time` → `timestamp`
+  - `severity` → `status`
+  - `progname` → `logger.name`
+  - `pid` → `pid`
+- **Exception Handling**: Structured exception logging with `kind`, `message`, and `stack` fields
+- **Duration Logging**: Automatic conversion of duration values to nanoseconds for DataDog
+- **Configurable Message Truncation**: Limit message length to prevent oversized logs
+- **Thread Information**: Optional thread name logging
+- **Tag Remapping**: Flexible tag transformation and remapping
+- **Pretty JSON**: Optional pretty-printed JSON output for development
+
+## Usage
+
+### Basic Setup
+
+```ruby
+require 'lumberjack_data_dog'
+
+# Create a logger that outputs to STDOUT
+logger = Lumberjack::DataDog.setup
+
+# Log messages
+logger.info("Application started")
+logger.warn("This is a warning", user_id: 123)
+logger.error("Something went wrong", request_id: "abc-123")
+```
+
+### Advanced Configuration
+
+```ruby
+logger = Lumberjack::DataDog.setup do |config|
+  # Truncate messages longer than 1000 characters
+  config.max_message_length = 1000
+
+  # Include thread information
+  config.thread_name = true  # or :global for global thread ID
+
+  # Disable PID logging
+  config.pid = false
+
+  # Remap custom tags to DataDog attributes
+  config.remap_tags(
+    user_id: "usr.id",
+    request_id: "http.request_id"
+  )
+
+  # Enable pretty JSON for development
+  config.pretty = true
+end
+```
+
+### Logging to a File
+
+```ruby
+# Log to a file instead of STDOUT
+File.open("/var/log/app.log", "a") do |file|
+  logger = Lumberjack::DataDog.setup(file)
+  logger.info("Logged to file")
+end
+```
+
+### Exception Logging
+
+Exceptions are automatically structured with DataDog's error attributes:
+
+```ruby
+begin
+  raise StandardError, "Something went wrong"
+rescue => e
+  # Results in structured error with error.kind, error.message, and error.stack fields
+  logger.error(e)
+end
+```
+
+### Duration Logging
+
+Duration values are automatically converted to nanoseconds:
+
+```ruby
+# Log execution time
+start_time = Time.now
+# ... do some work ...
+duration = Time.now - start_time
+
+logger.info("Operation completed", duration: duration)
+# duration is automatically converted to nanoseconds
+
+# You can also use specific duration units
+logger.info("DB query", duration_ms: 150.5)      # milliseconds
+logger.info("API call", duration_micros: 1500)   # microseconds
+logger.info("Function", duration_ns: 1500000)    # nanoseconds
+```
+
+### Custom Tag Transformation
+
+```ruby
+logger = Lumberjack::DataDog.setup do |config|
+  config.remap_tags(
+    # Simple remapping
+    correlation_id: "trace.correlation_id",
+
+    # Transform with a lambda
+    user_email: ->(email) { {"usr.email" => email.downcase} }
+  )
+end
+
+logger.info("User logged in", user_email: "USER@EXAMPLE.COM")
+# Results in usr.email: "user@example.com"
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "lumberjack_data_dog"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install lumberjack_data_dog
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/lumberjack/data_dog.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "lumberjack_json_device"
+
+module Lumberjack::DataDog
+  STANDARD_ATTRIBUTE_MAPPING = {
+    time: "timestamp",
+    severity: "status",
+    progname: ["logger", "name"],
+    pid: "pid"
+  }.freeze
+
+  class Config
+    attr_accessor :max_message_length
+    attr_accessor :backtrace_cleaner
+    attr_accessor :thread_name
+    attr_accessor :pid
+    attr_accessor :allow_all_tags
+    attr_reader :tag_mapping
+    attr_accessor :pretty
+
+    def initialize
+      @max_message_length = nil
+      @backtrace_cleaner = nil
+      @thread_name = false
+      @pid = true
+      @allow_all_tags = true
+      @tag_mapping = {}
+      @pretty = false
+    end
+
+    def remap_tags(tag_mapping)
+      @tag_mapping = @tag_mapping.merge(tag_mapping)
+    end
+
+    def validate!
+      if !max_message_length.nil? && (!max_message_length.is_a?(Integer) || max_message_length <= 0)
+        raise ArgumentError, "max_message_length must be a positive integer"
+      end
+
+      unless backtrace_cleaner.nil? || backtrace_cleaner.respond_to?(:clean)
+        raise ArgumentError, "backtrace_cleaner must respond to #clean"
+      end
+    end
+  end
+
+  class << self
+    def setup(stream = $stdout, &block)
+      config = Config.new
+      yield(config) if block_given?
+      config.validate!
+
+      new_logger(stream, config)
+    end
+
+    private
+
+    def new_logger(stream, config)
+      logger = Lumberjack::Logger.new(json_device(stream, config))
+
+      # Add the error to the error tag if an exception is logged as the message.
+      logger.message_formatter.add(Exception, message_exception_formatter)
+
+      # Split the error tag up into standard attributes if it is an exception.
+      logger.tag_formatter.add(Exception, exception_tag_formatter(config))
+
+      if config.thread_name
+        if config.thread_name == :global
+          logger.tag_globally("logger.thread_name" => -> { Lumberjack::Utils.global_thread_id })
+        else
+          logger.tag_globally("logger.thread_name" => -> { Lumberjack::Utils.thread_name })
+        end
+      end
+
+      if config.pid == :global
+        logger.tag_globally("pid" => -> { Lumberjack::Utils.global_pid })
+      end
+
+      logger
+    end
+
+    def json_device(stream, config)
+      Lumberjack::JsonDevice.new(stream, mapping: json_mapping(config), pretty: config.pretty)
+    end
+
+    def json_mapping(config)
+      mapping = config.tag_mapping.transform_keys(&:to_sym)
+      mapping = mapping.merge(STANDARD_ATTRIBUTE_MAPPING)
+
+      mapping.delete(:pid) if !config.pid || config.pid == :global
+
+      mapping[:tags] = "*" if config.allow_all_tags
+
+      mapping[:message] = if config.max_message_length
+        truncate_message_transformer(config.max_message_length)
+      else
+        "message"
+      end
+
+      mapping[:duration] = duration_nanosecond_transformer(1_000_000_000)
+      mapping[:duration_ms] = duration_nanosecond_transformer(1_000_000)
+      mapping[:duration_micros] = duration_nanosecond_transformer(1_000)
+      mapping[:duration_ns] = duration_nanosecond_transformer(1)
+
+      mapping.transform_keys!(&:to_s)
+    end
+
+    def truncate_message_transformer(max_length)
+      lambda do |msg|
+        msg = msg.inspect unless msg.is_a?(String)
+        msg = msg[0, max_length] if msg.is_a?(String) && msg.length > max_length
+        {"message" => msg}
+      end
+    end
+
+    def duration_nanosecond_transformer(multiplier)
+      lambda do |duration|
+        if duration.is_a?(Numeric)
+          {"duration" => (duration * multiplier).round}
+        else
+          {"duration" => nil}
+        end
+      end
+    end
+
+    def message_exception_formatter
+      lambda do |error|
+        Lumberjack::Formatter::TaggedMessage.new(error.inspect, error: error)
+      end
+    end
+
+    def exception_tag_formatter(config)
+      lambda do |error|
+        error_tags = {"kind" => error.class.name, "message" => error.message}
+        trace = error.backtrace
+        if trace
+          trace = config.backtrace_cleaner.clean(trace) if config.backtrace_cleaner
+          error_tags["stack"] = trace
+        end
+        error_tags
+      end
+    end
+  end
+end

data/lib/lumberjack_data_dog.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "lumberjack/data_dog"

data/lumberjack_data_dog.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |spec|
+  spec.name = "lumberjack_data_dog"
+  spec.version = File.read(File.join(__dir__, "VERSION")).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Lumberjack logging device that outputs JSON formatted for DataDog with standard attribute mapping."
+  spec.homepage = "https://github.com/bdurand/lumberjack_data_dog"
+  spec.license = "MIT"
+
+  # 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.
+  ignore_files = %w[
+    .gitignore
+    .travis.yml
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    gemfiles/
+    spec/
+  ]
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.5"
+
+  spec.add_dependency "lumberjack_json_device", ">= 2.0.0"
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lumberjack_data_dog
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lumberjack_json_device
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description:
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/dependabot.yml"
+- ".github/workflows/continuous_integration.yml"
+- ".standard.yml"
+- CHANGE_LOG.md
+- MIT_LICENSE.txt
+- README.md
+- VERSION
+- lib/lumberjack/data_dog.rb
+- lib/lumberjack_data_dog.rb
+- lumberjack_data_dog.gemspec
+homepage: https://github.com/bdurand/lumberjack_data_dog
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Lumberjack logging device that outputs JSON formatted for DataDog with standard
+  attribute mapping.
+test_files: []