vigilant-ruby 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5231f90612c18b1f92a9a2b0b1dcfb088ffc1a3c784061d61b15620a501d61d
-  data.tar.gz: 2a7089a1d46c396cd9d83eb594ac0cce35318f658af0b6df417415413f11f623
+  metadata.gz: 8f5caf9f04f2b348390785adcecf394cdc4580b753e6811bf18f9750f2c0dffd
+  data.tar.gz: fc84b996a2a961bcb614de7e4fb38edd35773960f159f400e8950278175cb3cf
 SHA512:
-  metadata.gz: 7c4f8e6f74900e48d2dd4efa4fdcd731ae5d937dd4c0ef7e5663e1ccdca17367a193cab9498f15365ba37c619af479cb527326e1e459a51ff43a6ae2ac7471ba
-  data.tar.gz: 67973be9091d86c9c02feef4f88f15b929d78d2eb612b5347245ce6e358ee42db9186a56b1ea3e79944c9074b334425f063495abb7679d139bcc53b4d056569c
+  metadata.gz: 2faaac39af894099aebf8b00679607eb535e6b4331d4f8da16239b463415c2a985e850f24fad682793549ddcb56a2574836de24d31f26633be7fe45faf7db2d7
+  data.tar.gz: 4d5844559329553a0e334c1dc5d7238a130e75c7c016ae162859303b0268052a212a9361c4588eaef251556b75b30f3cd6ece2e3d336198ae1a40682c5d91c70

data/lib/vigilant-ruby/logger.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'time'
+require 'vigilant-ruby/version'
+
+module Vigilant
+  DEBUG = 'DEBUG'
+  INFO = 'INFO'
+  WARNING = 'WARNING'
+  ERROR = 'ERROR'
+
+  DEFAULT_BATCH_SIZE = 10
+  DEFAULT_FLUSH_INTERVAL = 5
+
+  # A thread-safe logger that batches logs and sends them to Vigilant asynchronously
+  class Logger
+    # Initialize a Vigilant::Logger instance.
+    #
+    # @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:, insecure: false, passthrough: true)
+      @token = token
+
+      protocol = insecure ? 'http://' : 'https://'
+      endpoint = endpoint.sub(%r{^https?://}, '') # remove any existing protocol
+      @endpoint = URI.parse("#{protocol}#{endpoint}/api/message")
+
+      @insecure = insecure
+      @passthrough = passthrough
+
+      @batch_size     = DEFAULT_BATCH_SIZE
+      @flush_interval = DEFAULT_FLUSH_INTERVAL
+
+      @queue = Queue.new
+      @mutex = Mutex.new
+      @batch = []
+
+      @original_stdout = $stdout
+      @original_stderr = $stderr
+
+      @autocapture_enabled = false
+
+      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)
+      else
+        attributes_with_error = { error: error.message, **attributes }
+        enqueue_log(ERROR, body, attributes_with_error)
+      end
+    end
+
+    # Enables stdout/stderr autocapture.
+    def autocapture_enable
+      return if @autocapture_enabled
+
+      @autocapture_enabled = true
+      $stdout = StdoutInterceptor.new(self, @original_stdout)
+      $stderr = StderrInterceptor.new(self, @original_stderr)
+    end
+
+    # Disables stdout/stderr autocapture.
+    def autocapture_disable
+      return unless @autocapture_enabled
+
+      @autocapture_enabled = false
+      $stdout = @original_stdout
+      $stderr = @original_stderr
+    end
+
+    # Shuts down the logger, flushing any pending logs.
+    def shutdown
+      flush_if_needed(true)
+      @mutex.synchronize { @shutdown = true }
+      @dispatcher_thread&.join
+    end
+
+    private
+
+    def enqueue_log(level, body, attributes)
+      autocaptured = attributes.delete(:_autocapture)
+
+      log_msg = {
+        timestamp: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%9NZ'),
+        body: body.to_s,
+        level: level.to_s,
+        attributes: attributes.transform_values(&:to_s)
+      }
+
+      @queue << log_msg
+
+      return unless @passthrough && !autocaptured
+
+      @original_stdout.puts(body)
+    end
+
+    def start_dispatcher
+      @shutdown = false
+      @dispatcher_thread = Thread.new do
+        until @mutex.synchronize { @shutdown }
+          flush_if_needed
+          sleep @flush_interval
+        end
+        flush_if_needed(true)
+      end
+    end
+
+    def flush_if_needed(force: false)
+      until @queue.empty?
+        msg = @queue.pop
+        @mutex.synchronize { @batch << msg }
+      end
+
+      @mutex.synchronize do
+        flush! if force || @batch.size >= @batch_size || !@batch.empty?
+      end
+    end
+
+    def flush!
+      return if @batch.empty?
+
+      logs_to_send = @batch.dup
+      @batch.clear
+
+      request_body = {
+        token: @token,
+        type: 'logs',
+        logs: logs_to_send
+      }
+
+      post_logs(request_body)
+    rescue StandardError => e
+      warn("Failed to send logs: #{e.message}")
+    end
+
+    def post_logs(batch_data)
+      http = Net::HTTP.new(@endpoint.host, @endpoint.port)
+      http.use_ssl = !@insecure
+
+      request = Net::HTTP::Post.new(@endpoint)
+      request['Content-Type'] = 'application/json'
+      request.body = JSON.dump(batch_data)
+
+      http.request(request)
+    end
+  end
+
+  # Interceptor for capturing stdout
+  class StdoutInterceptor
+    def initialize(logger, original)
+      @logger   = logger
+      @original = original
+    end
+
+    def write(message)
+      @logger.info(message.strip, _autocapture: true) unless message.strip.empty?
+      @original.write(message)
+    end
+
+    def puts(*messages)
+      messages.each do |m|
+        @logger.info(m.to_s.strip, _autocapture: true) unless m.to_s.strip.empty?
+      end
+      @original.puts(*messages)
+    end
+
+    def print(*messages)
+      messages.each do |m|
+        @logger.info(m.to_s.strip, _autocapture: true) unless m.to_s.strip.empty?
+      end
+      @original.print(*messages)
+    end
+
+    def printf(*args)
+      formatted = sprintf(*args)
+      @logger.info(formatted.strip, _autocapture: true) unless formatted.strip.empty?
+      @original.printf(*args)
+    end
+
+    def flush
+      @original.flush
+    end
+
+    def close
+      @original.close
+    end
+
+    def tty?
+      @original.tty?
+    end
+
+    def respond_to_missing?(meth, include_private = false)
+      @original.respond_to?(meth, include_private)
+    end
+
+    def method_missing(meth, *args, &blk)
+      @original.send(meth, *args, &blk)
+    end
+  end
+
+  # Interceptor for capturing stderr
+  class StderrInterceptor
+    def initialize(logger, original)
+      @logger   = logger
+      @original = original
+    end
+
+    def write(message)
+      @logger.error(message.strip, nil, _autocapture: true) unless message.strip.empty?
+      @original.write(message)
+    end
+
+    def puts(*messages)
+      messages.each do |m|
+        @logger.error(m.to_s.strip, nil, _autocapture: true) unless m.to_s.strip.empty?
+      end
+      @original.puts(*messages)
+    end
+
+    def print(*messages)
+      messages.each do |m|
+        @logger.error(m.to_s.strip, nil, _autocapture: true) unless m.to_s.strip.empty?
+      end
+      @original.print(*messages)
+    end
+
+    def printf(*args)
+      formatted = sprintf(*args)
+      @logger.error(formatted.strip, nil, _autocapture: true) unless formatted.strip.empty?
+      @original.printf(*args)
+    end
+
+    def flush
+      @original.flush
+    end
+
+    def close
+      @original.close
+    end
+
+    def tty?
+      @original.tty?
+    end
+
+    def respond_to_missing?(meth, include_private = false)
+      @original.respond_to?(meth, include_private)
+    end
+
+    def method_missing(meth, *args, &blk)
+      @original.send(meth, *args, &blk)
+    end
+  end
+end

data/lib/{vigilant → vigilant-ruby}/version.rb

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

data/lib/vigilant-ruby.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'vigilant/version'
-require 'vigilant/logger'
+require 'vigilant-ruby/version'
+require 'vigilant-ruby/logger'
 
 # Vigilant is a logging service that provides structured logging capabilities
 # with asynchronous batch processing and thread-safe operations.
@@ -10,12 +10,13 @@ module Vigilant
 
   # Configuration for the Vigilant logging service.
   class Configuration
-    attr_accessor :endpoint, :token, :insecure
+    attr_accessor :endpoint, :token, :insecure, :passthrough
 
     def initialize
       @endpoint = 'ingress.vigilant.run'
       @insecure = false
       @token = 'tk_1234567890'
+      @passthrough = true
     end
   end
 
@@ -32,7 +33,8 @@ module Vigilant
       @logger ||= Vigilant::Logger.new(
         endpoint: configuration.endpoint,
         insecure: configuration.insecure,
-        token: configuration.token
+        token: configuration.token,
+        passthrough: configuration.passthrough
       )
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vigilant-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Vigilant
@@ -37,20 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -102,8 +88,8 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/vigilant-ruby.rb
-- lib/vigilant/logger.rb
-- lib/vigilant/version.rb
+- lib/vigilant-ruby/logger.rb
+- lib/vigilant-ruby/version.rb
 homepage: https://vigilant.run
 licenses:
 - MIT

data/lib/vigilant/logger.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require 'json'
-require 'time'
-require 'vigilant/version'
-
-module Vigilant
-  TRACE = 'TRACE'
-  DEBUG = 'DEBUG'
-  INFO = 'INFO'
-  WARNING = 'WARNING'
-  ERROR = 'ERROR'
-  FATAL = 'FATAL'
-
-  DEFAULT_BATCH_SIZE = 10
-  DEFAULT_FLUSH_INTERVAL = 5
-
-  # A thread-safe logger that batches logs and sends them to Vigilant asynchronously
-  class Logger
-    # Initialize a Vigilant::Logger instance.
-    #
-    # @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).
-    def initialize(endpoint:, token:, insecure: false)
-      @token = token
-      protocol = insecure ? 'http://' : 'https://'
-      endpoint = endpoint.sub(%r{^https?://}, '') # Remove any existing protocol
-      @endpoint = URI.parse("#{protocol}#{endpoint}/api/message")
-      @insecure = insecure
-
-      @batch_size = DEFAULT_BATCH_SIZE
-      @flush_interval = DEFAULT_FLUSH_INTERVAL
-
-      @queue = Queue.new
-      @mutex = Mutex.new
-      @batch = []
-
-      start_dispatcher
-    end
-
-    # Logs a TRACE message.
-    #
-    # @param body [String] The main text of the trace message.
-    # @param attributes [Hash] Additional attributes for the log (optional).
-    def trace(body, attributes = {})
-      enqueue_log(TRACE, body, attributes)
-    end
-
-    # Logs a DEBUG message.
-    #
-    # @param body [String] The main text of the debug message.
-    # @param attributes [Hash] Additional attributes for the log (optional).
-    def debug(body, attributes = {})
-      enqueue_log(DEBUG, body, attributes)
-    end
-
-    # Logs an INFO message.
-    #
-    # @param body [String] The main text of the log message.
-    # @param attributes [Hash] Additional attributes for the log (optional).
-    def info(body, attributes = {})
-      enqueue_log(INFO, body, attributes)
-    end
-
-    # Logs a WARNING message.
-    #
-    # @param body [String] The main text of the warning message.
-    # @param attributes [Hash] Additional attributes for the log (optional).
-    def warn(body, attributes = {})
-      enqueue_log(WARNING, body, attributes)
-    end
-
-    # Logs an ERROR message.
-    #
-    # @param body [String] The main text of the error message.
-    # @param error [Exception] The error object.
-    # @param attributes [Hash] Additional attributes for the log (optional).
-    def error(body, error = nil, attributes = {})
-      if error.nil?
-        enqueue_log(ERROR, body, attributes)
-      else
-        attributes_with_error = { error: error.message, **attributes }
-        enqueue_log(ERROR, body, attributes_with_error)
-      end
-    end
-
-    # Logs a FATAL message.
-    #
-    # @param body [String] The main text of the fatal message.
-    # @param attributes [Hash] Additional attributes for the log (optional).
-    def fatal(body, attributes = {})
-      enqueue_log(FATAL, body, attributes)
-    end
-
-    def shutdown
-      flush_if_needed(true)
-
-      @mutex.synchronize do
-        @shutdown = true
-      end
-
-      @dispatcher_thread&.join
-    end
-
-    private
-
-    def enqueue_log(level, body, attributes)
-      string_attributes = attributes.transform_values(&:to_s)
-      log_msg = {
-        timestamp: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%9NZ'),
-        body: body.to_s,
-        level: level.to_s,
-        attributes: string_attributes
-      }
-      @queue << log_msg
-    end
-
-    def start_dispatcher
-      @shutdown = false
-      @dispatcher_thread = Thread.new do
-        until @mutex.synchronize { @shutdown }
-          flush_if_needed
-          sleep @flush_interval
-        end
-        flush_if_needed(true)
-      end
-    end
-
-    def flush_if_needed(force = false)
-      until @queue.empty?
-        msg = @queue.pop
-        @mutex.synchronize { @batch << msg }
-      end
-
-      @mutex.synchronize do
-        flush! if force || @batch.size >= @batch_size || !@batch.empty?
-      end
-    end
-
-    def flush!
-      return if @batch.empty?
-
-      logs_to_send = @batch.dup
-      @batch.clear
-
-      request_body = {
-        token: @token,
-        type: 'logs',
-        logs: logs_to_send
-      }
-
-      post_logs(request_body)
-    rescue StandardError => e
-      warn("Failed to send logs: #{e.message}")
-    end
-
-    def post_logs(batch_data)
-      http = Net::HTTP.new(@endpoint.host, @endpoint.port)
-      http.use_ssl = !@insecure
-
-      request = Net::HTTP::Post.new(@endpoint)
-      request['Content-Type'] = 'application/json'
-      request.body = JSON.dump(batch_data)
-
-      http.request(request)
-    end
-  end
-end