gooddata 1.3.6-java → 2.0.0-java

data/lib/gooddata/bricks/middleware/context_manager.rb

@@ -0,0 +1,68 @@
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require_relative '../../mixins/property_accessor'
+require_relative '../../lcm/helpers/helpers'
+
+module GoodData
+  module ContextManager
+    extend GoodData::Mixin::PropertyAccessor
+
+    property_accessor :@context, :action
+    property_accessor :@context, :brick
+    property_accessor :@context, :execution_id
+    property_accessor :@context, :status
+
+    def initialize_context
+      @action_start = Time.now
+
+      # :log_v is used to differentiate new versions of logs in splunk
+      @context = {
+        :api_version => GoodData.version,
+        :log_v => 0,
+        :component => 'lcm.ruby',
+        :status => :not_in_action
+      }
+    end
+
+    # Return current brick context extended with time specific information
+    #
+    # @param [Time] now, allows to specify exact time, when outer call was performed
+    # @return [Hash] Brick context
+    def context(now = Time.now)
+      time_specific_context = action ? { :time => time_from_action_start(now) } : {}
+      @context.merge(time_specific_context)
+    end
+
+    def time_from_action_start(now = Time.now)
+      fail_if_development 'No action is being profiled' unless action
+      (now - @action_start) * 1000
+    end
+
+    # Starts lcm action
+    #
+    # @param [String] action, name of the action
+    # @param [Logger] logger, logger that should log current context info
+    # @param [Time] now, allows to specify exact time, when outer call was performed
+    def start_action(next_action, logger = nil, now = Time.now)
+      fail_if_development 'An action is already being profiled' if action
+
+      self.action = next_action
+      @action_start = now
+      logger.info '' if logger
+      self.status = :action_in_progress
+    end
+
+    # Ends currently opened lcm action
+    #
+    # @param [Logger] logger, logger that should log current context info
+    def end_action(logger = nil)
+      fail_if_development 'No matching action to start found' unless action
+
+      logger.info '' if logger
+      self.status = :not_in_action
+      self.action = nil
+    end
+  end
+end

data/lib/gooddata/bricks/middleware/gooddata_middleware.rb

@@ -26,6 +26,9 @@ module GoodData
       DEFAULT_HOSTNAME = 'secure.gooddata.com'
 
       def call(params)
+        # Generate brick execution id
+        execution_id = GoodData.gd_logger.execution_id
+
         # Convert possible jruby hash to plain hash
         params = params.to_hash
 
@@ -48,7 +51,8 @@ module GoodData
           params['GDC_VERIFY_SSL'].to_b,
           params['GDC_USERNAME'],
           params['GDC_PASSWORD'],
-          params['GDC_SST']
+          params['GDC_SST'],
+          execution_id
         )
 
         opts = params['development_client']
@@ -66,7 +70,8 @@ module GoodData
             opts['verify_ssl'].to_b,
             opts['username'] || opts['login'] || opts['email'],
             opts['password'],
-            opts['sst']
+            opts['sst'],
+            execution_id
           )
         else
           development_client = client
@@ -77,6 +82,7 @@ module GoodData
           'development_client' => development_client
         }
 
+        # collect parent project if deployed as process
         if params['GDC_PROJECT_ID']
           new_params['gdc_project'] = GoodData.project = client.projects(params['GDC_PROJECT_ID'])
         end
@@ -86,29 +92,29 @@ module GoodData
         # Try to disconnect client
         begin
           client.disconnect
-        rescue
-          GoodData.logger.warn('Tried to disconnect client. Was unsuccessful. Proceeding anyway.')
+        rescue StandardError => e
+          GoodData.logger.warn("Tried to disconnect client. Was unsuccessful. Proceeding anyway. Error: #{e}")
         end
 
         # Try to disconnect development_client
         begin
           development_client.disconnect if development_client != client
-        rescue
-          GoodData.logger.warn('Tried to disconnect development_client. Was unsuccessful. Proceeding anyway.')
+        rescue StandardError => e
+          GoodData.logger.warn("Tried to disconnect development_client. Was unsuccessful. Proceeding anyway. Error: #{e}")
         end
 
         returning_value
       end
 
       class << self
-        def connect(server, verify_ssl, username, password, sst_token) # rubocop:disable Metrics/ParameterLists
+        def connect(server, verify_ssl, username, password, sst_token, execution_id) # rubocop:disable Metrics/ParameterLists
           if username.nil? || password.nil?
             GoodData.logger.info("Connecting with SST to server #{server}")
             raise 'SST (SuperSecureToken) not present in params' if sst_token.nil?
-            conn = GoodData.connect(sst_token: sst_token, server: server, verify_ssl: verify_ssl)
+            conn = GoodData.connect(sst_token: sst_token, server: server, verify_ssl: verify_ssl, execution_id: execution_id)
           else
             GoodData.logger.info("Connecting as #{username} to server #{server}")
-            conn = GoodData.connect(username, password, server: server, verify_ssl: verify_ssl)
+            conn = GoodData.connect(username, password, server: server, verify_ssl: verify_ssl, execution_id: execution_id)
           end
           conn.stats_on
 

data/lib/gooddata/bricks/middleware/logger_middleware.rb

@@ -5,6 +5,7 @@
 # LICENSE file in the root directory of this source tree.
 
 require 'logger'
+require 'gooddata/core/splunk_logger'
 
 require 'gooddata/extensions/true'
 require 'gooddata/extensions/false'
@@ -20,6 +21,7 @@ using NilExtensions
 
 require_relative 'base_middleware'
 require_relative 'mask_logger_decorator'
+require_relative 'context_logger_decorator'
 
 module GoodData
   module Bricks
@@ -45,6 +47,24 @@ module GoodData
         params['GDC_LOGGER'] = logger
         GoodData.logging_http_on if params['HTTP_LOGGING'] && params['HTTP_LOGGING'].to_b
 
+        # Initialize splunk logger
+        if params['SPLUNK_LOGGING'] && params['SPLUNK_LOGGING'].to_b
+          GoodData.logger.info "Statistics collecting is turned ON. All the data is anonymous."
+          splunk_logger = SplunkLogger.new params['SPLUNK_LOG_PATH'] || GoodData::DEFAULT_SPLUNKLOG_OUTPUT
+          splunk_logger.level = params['SPLUNK_LOG_LEVEL'] || GoodData::DEFAULT_SPLUNKLOG_LEVEL
+          splunk_logger = splunk_logger.extend(ContextLoggerDecorator)
+          splunk_logger.context_source = GoodData.gd_logger
+          values_to_mask = params['values_to_mask'] || []
+          values_to_mask.concat MaskLoggerDecorator.extract_values params
+          splunk_logger = MaskLoggerDecorator.new(splunk_logger, values_to_mask) if values_to_mask.any?
+        else
+          splunk_logger = NilLogger.new
+        end
+        GoodData.splunk_logging_on splunk_logger
+
+        # Initialize context: Execution ID
+        GoodData.gd_logger.execution_id = params['GDC_EXECUTION_ID'] || SecureRandom.urlsafe_base64(16)
+
         returning(@app.call(params)) do |_result|
           logger.info('Pipeline ending')
         end

data/lib/gooddata/bricks/middleware/mask_logger_decorator.rb

@@ -14,6 +14,24 @@ module GoodData
         @values_to_mask = values_to_mask
       end
 
+      class << self
+        # Extract values to mask from structured data
+        # @param values [String] or [Hash] or [Array] structured data to be extracted
+        # @return [[String]] array of all String in values
+        def extract_values(values)
+          if values.is_a?(String)
+            [values]
+          elsif values.is_a?(Hash) || values.is_a?(Array)
+            (values.is_a?(Hash) ? values.values : values).reduce([]) do |strings, item|
+              strings.concat extract_values(item)
+              strings
+            end
+          else
+            []
+          end
+        end
+      end
+
       # log methods to be decorated
       %i[debug error fatal info unknown warn].each do |level|
         define_method level do |message|
@@ -21,14 +39,26 @@ module GoodData
         end
       end
 
-      private
+      # Decorator pretends being inner logger itselfs.
+      # @return inner logger class
+      def class
+        @logger.class
+      end
+
+      def add(severity, message = nil, progname = nil)
+        mask message
+        mask progname
+        @logger.add(severity, message, progname)
+      end
 
-      # Masks given message.
-      # @param message  [String] message to mask
-      # @return masked_message [String] masked message
+      # Masks given message
+      # @param message [String] or [Hash] or [Array] message to mask
+      # @return masked_message [String] or [Hash] or [Array] masked message
       def mask(message)
         unless message.nil?
-          @values_to_mask.reduce(message) do |masked_message, value_to_mask|
+          string = message.to_s
+
+          @values_to_mask.reduce(string) do |masked_message, value_to_mask|
             masked_message.gsub(value_to_mask, "******")
           end
         end

data/lib/gooddata/client.rb

@@ -42,8 +42,6 @@ require_relative 'core/core'
 
 module GoodData
   class << self
-    RELEASE_INFO_PATH = '/gdc/releaseInfo'
-
     # Initializes required dynamically loaded classes
     def init_module
       # Metadata packages, such as report.rb, require this to be loaded first
@@ -57,8 +55,9 @@ module GoodData
     end
 
     # Returns information about the GoodData API as a Hash (e.g. version, release time etc.)
+    # @deprecated The release info endpoint has been deprecated without a replacement.
     def release_info
-      @release_info ||= @connection.get(RELEASE_INFO_PATH)['release']
+      fail 'The release info endpoint has been deprecated without a replacement.'
     end
   end
 end

data/lib/gooddata/core/gd_logger.rb

@@ -0,0 +1,92 @@
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'logger'
+require 'gooddata/bricks/middleware/context_manager'
+require 'gooddata/rest/rest_aggregator'
+
+module GoodData
+  # This class delegates messages to multiple loggers
+  # By usage of [ContextManager] and [Rest::Aggregator] it stores information about context of execution
+  class GdLogger
+    severity_map = {
+      debug: Logger::DEBUG,
+      info: Logger::INFO,
+      warn: Logger::WARN,
+      error: Logger::ERROR,
+      fatal: Logger::FATAL,
+      unknown: Logger::UNKNOWN
+    }
+
+    attr_accessor :loggers
+
+    include ContextManager
+    include GoodData::Rest::Aggregator
+
+    def initialize
+      @loggers = {}
+      initialize_context
+      initialize_store
+    end
+
+    def logging_on(logger_id, logger)
+      loggers[logger_id] = logger
+    end
+
+    def logging_off(logger_id)
+      loggers[logger_id] = NilLogger.new
+    end
+
+    def logging_on?(logger_id)
+      loggers.key?(logger_id) && !loggers[logger_id].is_a?(NilLogger)
+    end
+
+    # Implementation of common logger methods
+    %i[debug error fatal info unknown warn].each do |severity|
+      # GdLogger delegates all records to all loggers
+      define_method severity do |progname = nil, &block|
+        add(severity_map[severity], nil, progname, &block)
+      end
+
+      # Returns [True] if any logger satisfies severity level
+      define_method severity.to_s + "?" do
+        test_severity severity
+      end
+    end
+
+    def test_severity(severity)
+      (loggers.values.map do |logger|
+        logger.send severity.to_s + "?"
+      end).any?
+    end
+
+    # Pass message to multiple loggers. By parameters some loggers might be filtered out and the message might be modified.
+    #
+    # @param severity, severity of record
+    # @param message, message to be logged
+    # @param progname, progname to be logged
+    def add(severity, message, progname, &block)
+      loggers.each do |_, logger|
+        logger.add(severity, message, progname, &block)
+      end
+    end
+
+    # Set logger level for specified logger
+    #
+    # @param level, severity level
+    # @param [Symbol] logger_name, logger which severity level should be changed
+    def level(level, logger_name)
+      loggers[logger_name].level = level
+    end
+
+    # Set logger level for all loggers
+    #
+    # @param level, severity level
+    def level=(level)
+      loggers.values.each do |logger|
+        logger.level = level
+      end
+    end
+  end
+end

data/lib/gooddata/core/logging.rb

@@ -7,6 +7,8 @@
 require 'rest-client'
 
 require_relative 'nil_logger'
+require_relative 'splunk_logger'
+require_relative 'gd_logger'
 
 module GoodData
   DEFAULT_LOG_LEVEL = Logger::INFO
@@ -17,8 +19,12 @@ module GoodData
   DEFAULT_RESTLOG_OUTPUT = STDOUT
   DEFAULT_RESTLOGGER_CLASS = Logger
 
+  DEFAULT_SPLUNKLOG_LEVEL = Logger::INFO
+  DEFAULT_SPLUNKLOG_OUTPUT = STDERR
+  DEFAULT_SPLUNKLOGGER_CLASS = SplunkLogger
+
   class << self
-    attr_accessor :logger, :rest_logger
+    attr_accessor :logger, :rest_logger, :gd_logger
     attr_writer :stats
 
     # Turn logging on
@@ -80,16 +86,23 @@ module GoodData
       !@rest_logger.instance_of?(NilLogger)
     end
 
-    def stats_on
-      @stats = true
+    # Turn splunk logging on
+    def splunk_logging_on(logger)
+      gd_logger.logging_on :splunk, logger
     end
 
-    def stats_on?
-      @stats
+    # Turn splunk logging off
+    #
+    # ### Example
+    #
+    #     GoodData.logging_splunk_off
+    #
+    def splunk_logging_off
+      gd_logger.logging_off :splunk
     end
 
-    def stats_off
-      @stats = false
+    def splunk_logging_on?
+      gd_logger.logging_on? :splunk
     end
 
     # Initial setup of logger
@@ -101,5 +114,9 @@ module GoodData
       DEFAULT_RESTLOG_OUTPUT,
       NilLogger
     )
+
+    # Initial setup of splunk logger
+    GoodData.gd_logger = GdLogger.new
+    GoodData.splunk_logging_off
   end
 end

data/lib/gooddata/core/nil_logger.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-#
 # Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
@@ -19,6 +17,7 @@ module GoodData
     alias_method :info, :debug
     alias_method :warn, :debug
     alias_method :error, :debug
+    alias_method :add, :debug
 
     def debug?
       false

data/lib/gooddata/core/splunk_logger.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'logger'
+
+module GoodData
+  # Logger that process given message to format readable by splunk
+  class SplunkLogger < Logger
+    def hash_to_string(hash)
+      hash.map { |pair| " #{pair[0]}=#{pair[1]}" }.join ""
+    end
+
+    # If the given message or progname is an instance of Hash, it's reformatted to splunk readable format.
+    # In case that the message or the progname contain new line character log won't be printed out.
+    # Otherwise splunk worker wouldn't process it correctly.
+    def add(severity, message = nil, progname = nil)
+      message = hash_to_string(message) if message.is_a? Hash
+      progname = hash_to_string(progname) if progname.is_a? Hash
+      super(severity, message, progname) unless (progname && progname.include?("\n")) || (message && message.include?("\n"))
+    end
+  end
+end