google_logger 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d992358263779aad83ebfcc34161a69d2ccad81ac6dba67dd36ac110a2b5d3c
+  data.tar.gz: 34612d6398a35047a3bba53fc83f59afd0ea58b84226c8b60f2c572c63a6b3df
+SHA512:
+  metadata.gz: d54e6e687f4afb7059bb366b198cd53ffc8a19882a88dda84d39efbd637eb77fced4a963a2df7c76e39612e5d9b2469eab8740b74f1c327fcb906863a5c19272
+  data.tar.gz: 11509739cfacf03d16a94722b63527d6d971c8ffd3b0be3df9c95d25026e45ff8c917c112aacfd90d94ca0c8e27eb57f0d7288a5e06b863aa72188e7f3a39f56

data/lib/google_logger.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'stackdriver'
+require 'google_logger/version'
+require 'google_logger/configuration'
+require 'google_logger/loggers/cloud_logger'
+require 'google_logger/loggers/local_logger'
+require 'google_logger/loggers/base'
+require 'google_logger/controller_logging'
+require 'google_logger/params_replacer'
+
+# Main module which should serve as an interface to all functionalities
+module GoogleLogger
+  class Error < StandardError; end
+
+  class InvalidConfigurationError < Error; end
+
+  class << self
+    attr_writer :configuration
+
+    # Returns GoogleLogger configuration
+    #
+    # @return [GoogleLogger::Configuration] current GoogleLogger configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Yields the cofiguration class
+    #
+    # @yield [GoogleLogger::Configuration] current GoogleLogger configuration
+    #
+    # @return [GoogleLogger::Configuration] GoogleLogger configuration with assigned values
+    def configure
+      yield(configuration) if block_given?
+
+      configuration.validate!
+
+      configuration
+    end
+
+    # Creates a new entry
+    #
+    # @param [String, Hash] payload content of the log
+    # @param [String] log_name log_name which can be used to filter logs
+    # @param [Symbol] severity severity of the log
+    #
+    # return [Boolean] `true` if the entry was successfully written
+    def create_entry(payload, log_name: 'default_log', severity: :DEFAULT)
+      logger_instance = logger
+      entry = logger_instance.build_entry(payload, log_name: log_name, severity: severity)
+      logger_instance.write_entry(entry)
+    end
+
+    # Creates a new entry for an exception which includes exception message, class and backtrace
+    #
+    # @param [StandardError] exception exception to be logged
+    #
+    # return [Boolean] `true` if the entry was successfully written
+    def log_exception(exception)
+      payload = {
+        message: exception.message,
+        exception: exception.class.name,
+        bactrace: exception.backtrace&.first(5)
+      }
+
+      create_entry(payload, log_name: 'error', severity: :ERROR)
+    rescue StandardError => e
+      log_google_logger_error(e)
+    end
+
+    # Creates a new entry for a controller request, the entry includes params,
+    # request URL, client ip address and http method
+    #
+    # @param [ActionDispatch::Request] request request to be logged
+    # @param [ActionController::StrongParameters] params parameters to be logged
+    #
+    # return [Boolean] `true` if the entry was successfully written
+    def log_request(request, params)
+      payload = {
+        params: params,
+        original_url: request.original_url,
+        ip: request.ip,
+        method: request.method
+      }
+
+      create_entry(payload, log_name: 'request', severity: :INFO)
+    rescue StandardError => e
+      log_google_logger_error(e)
+    end
+
+    # Returns the currently used logger
+    #
+    # @return [Object] GoogleLogger::Logger by default, local logger if `loc_locally` is set to true
+    def logger
+      if configuration.log_locally
+        Loggers::LocalLogger.new
+      else
+        Loggers::CloudLogger.new
+      end
+    end
+
+    # Log gem errors locally if local_logger is present
+    #
+    # @param [StandardError] exception the error that will be logged
+    def log_google_logger_error(exception)
+      local_logger = GoogleLogger.configuration.local_logger
+      local_logger.error "GOOGLE_LOGGER ERROR: #{exception.inspect}" if local_logger.present?
+    end
+
+    def deep_replace_secret_params(params)
+      ParamsReplacer.deep_replace_secret_params(params)
+    end
+  end
+end

data/lib/google_logger/configuration.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module GoogleLogger
+  class Configuration
+    attr_accessor(*%i[
+                    async
+                    resource_type
+                    resource_labels
+                    secret_params
+                    secret_param_value
+                    project_id
+                    credentials
+                    log_locally
+                    local_logger
+                  ])
+
+    # Creates a new instance with default configuration values
+    def initialize
+      @async = true
+      @resource_type = 'gae_app'
+      @resource_labels = {}
+      @secret_params = %i[password]
+      @secret_param_value = '<SECRET_PARAM>'
+      @log_locally = false
+    end
+
+    def validate!
+      if @log_locally
+        validate_local_logger
+      else
+        validate_credentials
+      end
+    end
+
+    private
+
+    def validate_local_logger
+      raise_invalid!('"local_logger" must be provided if "log_locally" is set to "true"') if local_logger.nil?
+
+      log_levels = GoogleLogger::Loggers::LocalLogger::SEVERITY_MAPPING.values.uniq + [:unknown]
+
+      # make sure the logger responds to logger methods
+      log_levels.each do |log_level|
+        raise_invalid!("\"local_logger\" must respond to \"#{log_level}\"") unless local_logger.respond_to?(log_level)
+      end
+    end
+
+    def validate_credentials
+      return unless @project_id.nil? || @project_id == '' || @credentials.nil? || @credentials == ''
+
+      raise_invalid!('"project_id" and "credentials" cannot be blank')
+    end
+
+    def raise_invalid!(message)
+      raise InvalidConfigurationError, message
+    end
+  end
+end

data/lib/google_logger/controller_logging.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module GoogleLogger
+  module ControllerLogging
+    extend ActiveSupport::Concern
+
+    included do
+      protected
+
+      # Logs the request and any uncaught exceptions, acts as an `around_action` filter.
+      # Exceptions are propagated so that they can be caught in the application.
+      def log_request_to_google
+        GoogleLogger.log_request(request, google_log_params)
+        yield
+      rescue StandardError => e
+        GoogleLogger.log_exception(e)
+        raise
+      end
+
+      # Returns params which should be logged, secret params have their value hidden before being logged
+      #
+      # @return [Hash] params hash with secret values hidden
+      def google_log_params
+        params_to_log = params.to_unsafe_h
+        GoogleLogger.deep_replace_secret_params(params_to_log)
+        params_to_log
+      end
+    end
+  end
+end

data/lib/google_logger/loggers/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GoogleLogger
+  module Loggers
+    class Base
+      protected
+
+      def configuration
+        GoogleLogger.configuration
+      end
+    end
+  end
+end

data/lib/google_logger/loggers/cloud_logger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'base'
+
+module GoogleLogger
+  module Loggers
+    class CloudLogger < Base
+      # Creates a new logger with project_id and credentials specified in configuration
+      def initialize
+        @project = Google::Cloud::Logging.new(
+          project_id: configuration.project_id,
+          credentials: configuration.credentials
+        )
+      end
+
+      # Builds a new entry
+      #
+      # @param [String, Hash] payload content of the log
+      # @param [String] log_name log_name which can be used to filter logs
+      # @param [Symbol] severity severity of the log
+      #
+      # @return [Google::Cloud::Logging::Entry] entry with payload and default resource configuration
+      def build_entry(payload, log_name: 'default_log', severity: :DEFAULT)
+        entry = @project.entry(payload: payload, log_name: log_name, severity: severity, timestamp: Time.now)
+        entry.resource.type = configuration.resource_type
+        entry.resource.labels = configuration.resource_labels
+        entry
+      end
+
+      # Writes an entry to google cloud
+      #
+      # @param [Google::Cloud::Logging::Entry] entry entry to be written to google cloud
+      # defaults to configuration value
+      #
+      # return [Boolean] `true` if the entry was successfully written
+      def write_entry(entry)
+        log_writer = configuration.async ? @project : @project.async_writer
+        log_writer.write_entries(entry)
+      end
+    end
+  end
+end

data/lib/google_logger/loggers/local_logger.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'base'
+
+module GoogleLogger
+  module Loggers
+    class LocalLogger < Base
+      SEVERITY_MAPPING = {
+        DEFAULT: :info,
+        DEBUG: :debug,
+        INFO: :info,
+        NOTICE: :info,
+        WARNING: :warn,
+        ERROR: :error,
+        CRITICAL: :fatal,
+        ALERT: :fatal,
+        EMERGENCY: :fatal
+      }.freeze
+
+      # Builds a new entry
+      #
+      # @param [String, Hash] payload content of the log
+      # @param [Hash] entry_args arguments which would normally be passed to google entry
+      #
+      # @return [Hash] entry with payload and default resource configuration
+      def build_entry(payload, entry_args = {})
+        entry_args[:payload] = payload
+        entry_args
+      end
+
+      # Writes an entry to google cloud
+      #
+      # @param [Hash] entry entry to be written to google cloud
+      #
+      # return [Boolean] `true` if the entry was successfully written
+      def write_entry(entry)
+        log_level = SEVERITY_MAPPING[entry[:severity]] || :unknown
+        configuration.local_logger.public_send(log_level, entry.inspect)
+
+        true
+      end
+    end
+  end
+end

data/lib/google_logger/params_replacer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module GoogleLogger
+  class ParamsReplacer
+    def deep_replace_secret_params(arg)
+      case arg
+      when Hash
+        deep_replace_params_in_hash(arg)
+      when Array
+        deep_replace_params_in_array(arg)
+      end
+    end
+
+    def deep_replace_params_in_hash(hash)
+      hash.each do |key, value|
+        if GoogleLogger.configuration.secret_params.include?(key.to_sym)
+          hash[key] = GoogleLogger.configuration.secret_param_value
+        else
+          deep_replace_secret_params(value)
+        end
+      end
+    end
+
+    def deep_replace_params_in_array(array)
+      array.each { |item| deep_replace_secret_params(item) }
+    end
+
+    class << self
+      delegate :deep_replace_secret_params, to: :new
+    end
+  end
+end

data/lib/google_logger/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GoogleLogger
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: google_logger
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jan Hric
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.4.5
+- !ruby/object:Gem::Dependency
+  name: stackdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.1
+description: |-
+  Provides convenient methods to log all controller requests
+                         and also provides a wrapper class which simplifies custom logging.
+email:
+- hric95@seznam.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/google_logger.rb
+- lib/google_logger/configuration.rb
+- lib/google_logger/controller_logging.rb
+- lib/google_logger/loggers/base.rb
+- lib/google_logger/loggers/cloud_logger.rb
+- lib/google_logger/loggers/local_logger.rb
+- lib/google_logger/params_replacer.rb
+- lib/google_logger/version.rb
+homepage: https://github.com/panter/google_logger
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/panter/google_logger
+  source_code_uri: https://github.com/panter/google_logger
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- lib/google_logger
+- lib/google_logger/loggers
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.7.6.2
+signing_key:
+specification_version: 4
+summary: Provides a simple interface to write logs to the google cloud platform.
+test_files: []