vigilant-ruby 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f7f1ed256105eb26d3eca1221963c0cb0db06d2fab56630059fc3fc7d064e34
-  data.tar.gz: ff68b2953e375a0e9e741914aca017b614b689870ba4e728e8d153d496c8e38f
+  metadata.gz: d1922622d6ddc6f7e1630e48672cd6d78c8d988436319af621e8c9a6e688dbd6
+  data.tar.gz: b73e50dca1371a51a5e7f83d1016e0b16b1c1d9ff43043bc280a418edd3ff3f9
 SHA512:
-  metadata.gz: 931ce0b4a70c782502d0771cf967517d8cc58556f2a69b0fc9a65195f7065f22df5cbcdf538fd5f568a24f2f2625b5fd3bac75f2a181585ceec8f06ee037c4f2
-  data.tar.gz: f7bf06387f135895cc032b9af406bf5ef2b19d3fc41796d8a2ddbb563fa4f55cfcc570faa489f55c524c7a20e1807919b0c11e60feef4431d502a061b2f279ce
+  metadata.gz: 84dc689092a381d52aa4740a894d42fe95dc6e744c739b44daf92777cefece4711260c0f05f5e05f15964cdfcf03783d0b881fd06eda13a8a0fa98b627941967
+  data.tar.gz: b60229476423fffa95cd0697de5b3e8e7151eba286905ed0a08b8419781aa3ae0b4254ade52c909cba2539f3f62c0ad425cecc639ba2f16c1925c0c8b79da13f

data/README.md

@@ -5,7 +5,21 @@ This is the Ruby SDK for Vigilant (https://vigilant.run).
 ## Installation
 
 ```bash
-gem install vigilant-ruby
+bundle add vigilant-ruby
+```
+
+## Logging Usage (Rails)
+
+```ruby
+# In config/application.rb
+require 'vigilant-ruby'
+
+module YourApp
+  class Application < Rails::Application
+    config.logger = Vigilant::Rails::Logger.new(token: 'tk_1234567890', name: 'test-app')
+    config.log_level = :debug
+  end
+end
 ```
 
 ## Logging Usage (Standard)
@@ -16,8 +30,7 @@ require 'vigilant-ruby'
 # Initialize the logger
 logger = Vigilant::Logger.new(
   name: 'test-app',
-  endpoint: "ingress.vigilant.run",
-  token: "tk_0000000000000000",
+  token: 'tk_1234567890',
 )
 
 # Basic logging
@@ -41,18 +54,17 @@ require 'vigilant-ruby'
 # Initialize the logger
 logger = Vigilant::Logger.new(
   name: 'test-app',
-  endpoint: "ingress.vigilant.run",
-  token: "tk_0000000000000000",
+  token: 'tk_1234567890',
 )
 
 # Enable autocapture
 logger.autocapture_enable
 
 # Log with autocapture
-puts "A print statement"
+puts 'A print statement'
 
 # Log without autocapture
-logger.info("A regular log")
+logger.info('A regular log')
 
 # Shutdown the logger
 logger.shutdown

data/lib/vigilant-ruby/logger.rb

@@ -22,8 +22,8 @@ module Vigilant
     # @param endpoint [String] The base endpoint for the Vigilant API (e.g. "ingress.vigilant.run").
     # @param token [String] The authentication token for the Vigilant API.
     # @param insecure [Boolean] Whether to use HTTP instead of HTTPS (optional, defaults to false).
-    # @param passthrough [Boolean] Whether to also print logs to stdout/stderr (optional, defaults to true).
-    def initialize(endpoint:, token:, name: 'test-app', insecure: false, passthrough: true)
+    # @param passthrough [Boolean] Whether to also print logs to stdout/stderr (optional, defaults to false).
+    def initialize(name:, token:, endpoint:, insecure: false, passthrough: false)
       @name = name
       @token = token
 
@@ -49,22 +49,18 @@ module Vigilant
       start_dispatcher
     end
 
-    # Logs a debug message.
     def debug(body, attributes = {})
       enqueue_log(DEBUG, body, attributes)
     end
 
-    # Logs an info message.
     def info(body, attributes = {})
       enqueue_log(INFO, body, attributes)
     end
 
-    # Logs a warning message.
     def warn(body, attributes = {})
       enqueue_log(WARNING, body, attributes)
     end
 
-    # Logs an error message.
     def error(body, error = nil, attributes = {})
       if error.nil?
         enqueue_log(ERROR, body, attributes)
@@ -74,7 +70,6 @@ module Vigilant
       end
     end
 
-    # Enables stdout/stderr autocapture.
     def autocapture_enable
       return if @autocapture_enabled
 
@@ -83,7 +78,6 @@ module Vigilant
       $stderr = StderrInterceptor.new(self, @original_stderr)
     end
 
-    # Disables stdout/stderr autocapture.
     def autocapture_disable
       return unless @autocapture_enabled
 
@@ -92,7 +86,6 @@ module Vigilant
       $stderr = @original_stderr
     end
 
-    # Shuts down the logger, flushing any pending logs.
     def shutdown
       flush_if_needed(force: true)
       @mutex.synchronize { @shutdown = true }

data/lib/vigilant-ruby/rails/logger.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'active_support/logger'
+require 'json'
+
+module Vigilant
+  module Rails
+    # A wrapper that delegates Rails-style logging calls to Vigilant::Logger
+    class Logger < ::ActiveSupport::Logger
+      include ::ActiveSupport::LoggerThreadSafeLevel if defined?(::ActiveSupport::LoggerThreadSafeLevel)
+
+      if defined?(::ActiveSupport::LoggerSilence)
+        include ::ActiveSupport::LoggerSilence
+      elsif defined?(::LoggerSilence)
+        include ::LoggerSilence
+      end
+
+      SEVERITY_MAP = {
+        ::Logger::DEBUG => Vigilant::DEBUG,
+        ::Logger::INFO => Vigilant::INFO,
+        ::Logger::WARN => Vigilant::WARNING,
+        ::Logger::ERROR => Vigilant::ERROR,
+        ::Logger::FATAL => Vigilant::ERROR,
+        ::Logger::UNKNOWN => Vigilant::ERROR
+      }.freeze
+
+      def initialize(name: Vigilant.configuration.name,
+                     endpoint: Vigilant.configuration.endpoint,
+                     token: Vigilant.configuration.token,
+                     insecure: Vigilant.configuration.insecure,
+                     passthrough: Vigilant.configuration.passthrough)
+        super(nil)
+
+        @vigilant_logger = Vigilant::Logger.new(
+          endpoint: endpoint,
+          token: token,
+          name: name,
+          insecure: insecure,
+          passthrough: passthrough
+        )
+
+        at_exit { close }
+
+        self.level = ::Logger::DEBUG
+        @tags = []
+        @extra_loggers = []
+      end
+
+      def kind_of?(klass)
+        return true if defined?(::ActiveSupport::BroadcastLogger) && klass == ::ActiveSupport::BroadcastLogger
+
+        super(klass)
+      end
+      alias is_a? kind_of?
+
+      def broadcasts
+        [self] + @extra_loggers
+      end
+
+      def broadcast_to(*io_devices_and_loggers)
+        io_devices_and_loggers.each do |io_device_or_logger|
+          extra_logger =
+            if io_device_or_logger.is_a?(::Logger)
+              io_device_or_logger
+            else
+              ::ActiveSupport::Logger.new(io_device_or_logger)
+            end
+          @extra_loggers << extra_logger
+        end
+      end
+
+      def stop_broadcasting_to(io_device_or_logger)
+        if io_device_or_logger.is_a?(::Logger)
+          @extra_loggers.delete(io_device_or_logger)
+        else
+          @extra_loggers.reject! do |logger|
+            defined?(::ActiveSupport::Logger) &&
+              ::ActiveSupport::Logger.logger_outputs_to?(logger, io_device_or_logger)
+          end
+        end
+      end
+
+      def debug(progname = nil, &block)
+        add(::Logger::DEBUG, block, progname)
+      end
+
+      def info(progname = nil, &block)
+        add(::Logger::INFO, block, progname)
+      end
+
+      def warn(progname = nil, &block)
+        add(::Logger::WARN, block, progname)
+      end
+
+      def error(progname = nil, &block)
+        add(::Logger::ERROR, block, progname)
+      end
+
+      def fatal(progname = nil, &block)
+        add(::Logger::FATAL, block, progname)
+      end
+
+      def unknown(progname = nil, &block)
+        add(::Logger::UNKNOWN, block, progname)
+      end
+
+      def add(severity, message_or_block = nil, progname = nil)
+        return true if severity < level
+
+        msg =
+          if message_or_block.respond_to?(:call)
+            message_or_block.call.to_s
+          else
+            (message_or_block || progname).to_s
+          end.strip
+
+        vigilant_severity = SEVERITY_MAP.fetch(severity, Vigilant::ERROR)
+        log_to_vigilant(vigilant_severity, msg)
+
+        @extra_loggers.each { |logger| logger.add(severity, msg, progname) }
+        true
+      end
+
+      def tagged(*tags)
+        push_tags(*tags)
+        yield self
+      ensure
+        pop_tags(tags.size)
+      end
+
+      def push_tags(*tags)
+        @tags.concat(tags)
+      end
+
+      def pop_tags(amount = 1)
+        @tags.pop(amount)
+      end
+
+      def current_tags
+        @tags
+      end
+
+      def silence(temporary_level = ::Logger::ERROR)
+        old_level = level
+        self.level = temporary_level
+        yield self
+      ensure
+        self.level = old_level
+      end
+
+      def flush
+        @vigilant_logger.flush if @vigilant_logger.respond_to?(:flush)
+      rescue StandardError
+        nil
+      end
+
+      def reopen(_device = nil)
+        nil
+      end
+
+      def close
+        @vigilant_logger.shutdown if @vigilant_logger.respond_to?(:shutdown)
+      end
+
+      def datetime_format=(_format)
+        nil
+      end
+
+      def datetime_format
+        nil
+      end
+
+      attr_accessor :formatter
+
+      private
+
+      def log_to_vigilant(severity, message)
+        formatted_message, attributes = format_message(message)
+        case severity
+        when Vigilant::DEBUG
+          @vigilant_logger.debug(formatted_message, attributes)
+        when Vigilant::INFO
+          @vigilant_logger.info(formatted_message, attributes)
+        when Vigilant::WARNING
+          @vigilant_logger.warn(formatted_message, attributes)
+        when Vigilant::ERROR
+          @vigilant_logger.error(formatted_message, nil, attributes)
+        end
+      end
+
+      def format_message(message)
+        formatted_message = format_tags(message)
+        attributes = {}
+
+        begin
+          attributes = format_json_attributes(message) if message.start_with?('{') && message.end_with?('}')
+        rescue JSON::ParserError
+          nil
+        end
+
+        begin
+          attributes = format_key_value_attributes(message) if message.match?(/^[\w\-.]+=/)
+        rescue StandardError
+          nil
+        end
+
+        [formatted_message, attributes]
+      end
+
+      def format_json_attributes(message)
+        json_data = JSON.parse(message)
+        attributes = json_data['attributes'] ||= {}
+
+        json_data.each do |key, value|
+          attributes[key] = value
+          json_data.delete(key)
+        end
+
+        attributes['tags'] = @tags
+        attributes
+      end
+
+      def format_key_value_attributes(message)
+        attributes = {}
+        message.split(' ').each do |pair|
+          key, value = pair.split('=', 2)
+          value = case value
+                  when /^\d+$/
+                    value.to_i
+                  when /^\d*\.\d+$/
+                    value.to_f
+                  else
+                    value
+                  end
+          attributes[key] = value
+        end
+
+        attributes['tags'] = @tags
+        attributes
+      end
+
+      def format_tags(message)
+        tag_prefix = @tags.map { |t| "[#{t}] " }.join
+        "#{tag_prefix}#{message}"
+      end
+    end
+  end
+end

data/lib/vigilant-ruby/rails/railtie.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+require 'vigilant-ruby/logger'
+require 'vigilant-ruby/rails/logger'
+
+module Vigilant
+  module Rails
+    # Railtie for integrating Vigilant with Rails.
+    class Railtie < ::Rails::Railtie
+      initializer 'vigilant.rails_integration' do
+        nil
+      end
+    end
+  end
+end

data/lib/vigilant-ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vigilant
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/lib/vigilant-ruby.rb

@@ -2,21 +2,22 @@
 
 require 'vigilant-ruby/version'
 require 'vigilant-ruby/logger'
+require 'vigilant-ruby/rails/railtie' if defined?(Rails)
 
-# Vigilant is a logging service that provides structured logging capabilities
-# with asynchronous batch processing and thread-safe operations.
+# Vigilant is a logging library for the Vigilant platform.
 module Vigilant
   class Error < StandardError; end
 
   # Configuration for the Vigilant logging service.
   class Configuration
-    attr_accessor :endpoint, :token, :insecure, :passthrough
+    attr_accessor :name, :token, :endpoint, :insecure, :passthrough
 
     def initialize
+      @name = 'test-app'
+      @token = 'tk_1234567890'
       @endpoint = 'ingress.vigilant.run'
       @insecure = false
-      @token = 'tk_1234567890'
-      @passthrough = true
+      @passthrough = false
     end
   end
 
@@ -31,9 +32,10 @@ module Vigilant
 
     def logger
       @logger ||= Vigilant::Logger.new(
+        name: configuration.name,
+        token: configuration.token,
         endpoint: configuration.endpoint,
         insecure: configuration.insecure,
-        token: configuration.token,
         passthrough: configuration.passthrough
       )
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: vigilant-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Vigilant
 bindir: bin
 cert_chain: []
-date: 2025-01-27 00:00:00.000000000 Z
+date: 2025-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -89,6 +89,8 @@ files:
 - README.md
 - lib/vigilant-ruby.rb
 - lib/vigilant-ruby/logger.rb
+- lib/vigilant-ruby/rails/logger.rb
+- lib/vigilant-ruby/rails/railtie.rb
 - lib/vigilant-ruby/version.rb
 homepage: https://vigilant.run
 licenses: