bizside 2.0.1

data/lib/bizside/audit_log.rb

@@ -0,0 +1,158 @@
+require_relative 'audit/logger'
+
+module Bizside
+  class AuditLog
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      start = Time.now.strftime('%Y-%m-%dT%H:%M:%S.%3N%z')
+      @status, @headers, @response = @app.call(env)
+      stop = Time.now.strftime('%Y-%m-%dT%H:%M:%S.%3N%z')      
+      exception = env[Bizside::ShowExceptions::BIZSIDE_EXCEPTION_ENV_KEY]
+
+      if env['BIZSIDE_SUPPRESS_AUDIT']
+        return @status, @headers, @response
+      end
+
+      if Bizside.rails_env&.development?
+        return @status, @headers, @response if env['REQUEST_URI'] =~ /\/[^\/]+\/assets\/.*/
+      elsif Bizside.rails_env&.test?
+        return @status, @headers, @response
+      end
+
+      info = build_loginfo(env, start, stop, @status, exception)
+      logger.record(info)
+
+      return @status, @headers, @response
+    end
+
+    private
+
+    def logger
+      @logger ||= Bizside::Audit::Logger.logger
+    end
+
+    def build_loginfo(env, start, stop, status, exception)
+      info = {
+        time: start,
+        add_on_name: detect_add_on_name(env),
+        feature: detect_feature(env),
+        action: detect_action(env),
+        data: detect_data(env),
+        interactive: detect_interactive(env),
+        company: detect_company(env),
+        user: detect_user(env),
+        employee_code: detect_employee_code(env),
+        department: detect_department(env),
+        project: detect_project(env),
+        server_name: env['SERVER_NAME'],
+        server_address: ENV['HOSTNAME'] || env['SERVER_ADDR'], # nginx と apache で異なる
+        server_port: env['SERVER_PORT'],
+        scheme: env['rack.url_scheme'],
+        path: env['PATH_INFO'],
+        referrer: env['HTTP_REFERER'],
+        request_method: env['REQUEST_METHOD'],
+        request_uri: env['BIZSIDE_REQUEST_URI'].presence || env['REQUEST_URI'],
+        remote_address: env['REMOTE_ADDR'],
+        status: status,
+        started_at: start,
+        finished_at: stop,
+        device: detect_device(env),
+        user_agent: detect_user_agent(env),
+        exception: detect_exception(exception),
+        exception_message: detect_exception_message(exception),
+        exception_backtrace: detect_exception_backtrace(exception)
+      }
+
+      info
+    end
+
+    def detect_company(env)
+      env['BIZSIDE_COMPANY']
+    end
+
+    def detect_user(env)
+      ret = env['BIZSIDE_USER']
+      ret ||= Bizside::ShibUtils._get_bizside_user(env)
+      
+      if ret.to_s.empty?
+        if defined?(Devise)
+          warden = env['warden']
+          if warden.authenticate?
+            auth_user = warden.send(warden.config[:default_scope])
+            ret = auth_user.email
+          end
+        end
+      end
+
+      ret
+    end
+
+    def detect_add_on_name(env)
+      ret = env['BIZSIDE_ADD_ON_NAME']
+      ret ||= Bizside.config.add_on_name
+      ret
+    end
+
+    def detect_feature(env)
+      env['BIZSIDE_FEATURE']
+    end
+
+    def detect_action(env)
+      env['BIZSIDE_ACTION']
+    end
+
+    def detect_data(env)
+      env['BIZSIDE_DATA']
+    end
+
+    def detect_interactive(env)
+      env['BIZSIDE_INTERACTIVE']
+    end
+
+    def detect_department(env)
+      env['BIZSIDE_DEPARTMENT']
+    end
+
+    def detect_project(env)
+      env['BIZSIDE_PROJECT']
+    end
+
+    def detect_device(env)
+      env['BIZSIDE_DEVICE']
+    end
+
+    def detect_user_agent(env)
+      ret = env['BIZSIDE_USER_AGENT']
+      ret ||= env['HTTP_USER_AGENT']
+      ret
+    end
+
+    def detect_employee_code(env)
+      ret = env['BIZSIDE_EMPLOYEE_CODE']
+      ret
+    end
+
+    def detect_exception(exception)
+      return '' unless exception
+
+      exception.class.name
+    end
+
+    def detect_exception_message(exception)
+      return '' unless exception
+
+      exception.to_s
+    end
+
+    def detect_exception_backtrace(exception)
+      return '' unless exception
+
+      exception.backtrace.join("\n")
+    end
+
+  end
+end

data/lib/bizside/cache/entry.rb

@@ -0,0 +1,112 @@
+module Bizside
+  module Cache
+    class Entry
+      DEFAULT_COMPRESS_LIMIT = 16.kilobytes
+
+      def initialize(value, options = {})
+        if should_compress?(value, options)
+          @value = compress(value)
+          @compressed = true
+        else
+          @value = value
+        end
+
+        @created_at = Time.now.to_f
+        @expires_in = options[:expires_in]
+        @expires_in = @expires_in.to_f if @expires_in
+      end
+
+      def value
+        convert_version_4beta1_entry! if defined?(@v)
+        compressed? ? uncompress(@value) : @value
+      end
+
+      def expired?
+        convert_version_4beta1_entry! if defined?(@v)
+        @expires_in && @created_at + @expires_in <= Time.now.to_f
+      end
+
+      def expires_at
+        @expires_in ? @created_at + @expires_in : nil
+      end
+
+      def expires_at=(value)
+        if value
+          @expires_in = value.to_f - @created_at
+        else
+          @expires_in = nil
+        end
+      end
+
+      def size
+        if defined?(@s)
+          @s
+        else
+          case value
+          when NilClass
+            0
+          when String
+            @value.bytesize
+          else
+            @s = Marshal.dump(@value).bytesize
+          end
+        end
+      end
+
+      def dup_value!
+        convert_version_4beta1_entry! if defined?(@v)
+
+        if @value && !compressed? && !(@value.is_a?(Numeric) || @value == true || @value == false)
+          if @value.is_a?(String)
+            @value = @value.dup
+          else
+            @value = Marshal.load(Marshal.dump(@value))
+          end
+        end
+      end
+
+      private
+      
+      def should_compress?(value, options)
+        if value && options[:compress]
+          compress_threshold = options[:compress_threshold] || DEFAULT_COMPRESS_LIMIT
+          serialized_value_size = (value.is_a?(String) ? value : Marshal.dump(value)).bytesize
+
+          return true if serialized_value_size >= compress_threshold
+        end
+
+        false
+      end
+
+      def compressed?
+        defined?(@compressed) ? @compressed : false
+      end
+
+      def compress(value)
+        Zlib::Deflate.deflate(Marshal.dump(value))
+      end
+
+      def uncompress(value)
+        Marshal.load(Zlib::Inflate.inflate(value))
+      end
+
+      def convert_version_4beta1_entry!
+        if defined?(@v)
+          @value = @v
+          remove_instance_variable(:@v)
+        end
+
+        if defined?(@c)
+          @compressed = @c
+          remove_instance_variable(:@c)
+        end
+
+        if defined?(@x) && @x
+          @created_at ||= Time.now.to_f
+          @expires_in = @x - @created_at
+          remove_instance_variable(:@x)
+        end
+      end
+    end
+  end
+end

data/lib/bizside/cache/file_store.rb

@@ -0,0 +1,167 @@
+require 'bizside/cache/store'
+
+module Bizside
+  module Cache
+    class FileStore < Store
+  
+      attr_reader :cache_path
+
+      DIR_FORMATTER = "%03X"
+      FILENAME_MAX_SIZE = 228 # max filename size on file system is 255, minus room for timestamp and random characters appended by Tempfile (used by atomic write)
+      FILEPATH_MAX_SIZE = 900 # max is 1024, plus some room
+      EXCLUDED_DIRS = ['.', '..'].freeze
+
+      def initialize(cache_path, options = nil)
+        super(options)
+        @cache_path = cache_path.to_s
+      end
+
+      def clear(options = nil)
+        root_dirs = Dir.entries(cache_path).reject {|f| (EXCLUDED_DIRS + [".gitkeep"]).include?(f)}
+        FileUtils.rm_r(root_dirs.collect{|f| File.join(cache_path, f)})
+      end
+
+      def cleanup(options = nil)
+        options = merged_options(options)
+        search_dir(cache_path) do |fname|
+          key = file_path_key(fname)
+          entry = read_entry(key, options)
+          delete_entry(key, options) if entry && entry.expired?
+        end
+      end
+
+      def increment(name, amount = 1, options = nil)
+        modify_value(name, amount, options)
+      end
+
+      def decrement(name, amount = 1, options = nil)
+        modify_value(name, -amount, options)
+      end
+
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        instrument(:delete_matched, matcher.inspect) do
+          matcher = key_matcher(matcher, options)
+          search_dir(cache_path) do |path|
+            key = file_path_key(path)
+            delete_entry(key, options) if key.match(matcher)
+          end
+        end
+      end
+
+      protected
+
+      def read_entry(key, options)
+        file_name = key_file_path(key)
+        if File.exist?(file_name)
+          File.open(file_name) { |f| Marshal.load(f) }
+        end
+      rescue => e
+        nil
+      end
+
+      def write_entry(key, entry, options)
+        file_name = key_file_path(key)
+        return false if options[:unless_exist] && File.exist?(file_name)
+        ensure_cache_path(File.dirname(file_name))
+        File.atomic_write(file_name, cache_path) {|f| Marshal.dump(entry, f)}
+        true
+      end
+
+      def delete_entry(key, options)
+        file_name = key_file_path(key)
+        if File.exist?(file_name)
+          begin
+            File.delete(file_name)
+            delete_empty_directories(File.dirname(file_name))
+            true
+          rescue => e
+            raise e if File.exist?(file_name)
+            false
+          end
+        end
+      end
+
+      private
+      
+      def lock_file(file_name, &block)
+        if File.exist?(file_name)
+          File.open(file_name, 'r+') do |f|
+            begin
+              f.flock File::LOCK_EX
+              yield
+            ensure
+              f.flock File::LOCK_UN
+            end
+          end
+        else
+          yield
+        end
+      end
+
+      def key_file_path(key)
+        if key.size > FILEPATH_MAX_SIZE
+          key = Digest::MD5.hexdigest(key)
+        end
+
+        fname = URI.encode_www_form_component(key)
+        hash = Zlib.adler32(fname)
+        hash, dir_1 = hash.divmod(0x1000)
+        dir_2 = hash.modulo(0x1000)
+        fname_paths = []
+
+        begin
+          fname_paths << fname[0, FILENAME_MAX_SIZE]
+          fname = fname[FILENAME_MAX_SIZE..-1]
+        end until fname.blank?
+
+        File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
+      end
+
+      def file_path_key(path)
+        fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last
+        URI.decode_www_form_component(fname, Encoding::UTF_8)
+      end
+
+      def delete_empty_directories(dir)
+        return if File.realpath(dir) == File.realpath(cache_path)
+        if Dir.entries(dir).reject {|f| EXCLUDED_DIRS.include?(f)}.empty?
+          Dir.delete(dir) rescue nil
+          delete_empty_directories(File.dirname(dir))
+        end
+      end
+
+      def ensure_cache_path(path)
+        FileUtils.makedirs(path) unless File.exist?(path)
+      end
+
+      def search_dir(dir, &callback)
+        return if !File.exist?(dir)
+        Dir.foreach(dir) do |d|
+          next if EXCLUDED_DIRS.include?(d)
+          name = File.join(dir, d)
+          if File.directory?(name)
+            search_dir(name, &callback)
+          else
+            callback.call name
+          end
+        end
+      end
+
+      def modify_value(name, amount, options)
+        file_name = key_file_path(namespaced_key(name, options))
+
+        lock_file(file_name) do
+          options = merged_options(options)
+
+          if num = read(name, options)
+            num = num.to_i + amount
+            write(name, num, options)
+            num
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/bizside/cache/store.rb

@@ -0,0 +1,237 @@
+require 'bizside/cache/entry'
+
+module Bizside
+  module Cache
+    class Store
+      
+      attr_reader :options
+      
+      def initialize(options = nil)
+        @options = options ? options.dup : {}
+      end
+  
+      def fetch(name, options = nil)
+        if block_given?
+          options = merged_options(options)
+          key = namespaced_key(name, options)
+
+          cached_entry = find_cached_entry(key, name, options) unless options[:force]
+          entry = handle_expired_entry(cached_entry, key, options)
+
+          if entry
+            get_entry_value(entry, name, options)
+          else
+            save_block_result_to_cache(name, options) { |_name| yield _name }
+          end
+        else
+          read(name, options)
+        end
+      end
+
+      def read(name, options = nil)
+        options = merged_options(options)
+        key = namespaced_key(name, options)
+        instrument(:read, name, options) do |payload|
+          entry = read_entry(key, options)
+          if entry
+            if entry.expired?
+              delete_entry(key, options)
+              payload[:hit] = false if payload
+              nil
+            else
+              payload[:hit] = true if payload
+              entry.value
+            end
+          else
+            payload[:hit] = false if payload
+            nil
+          end
+        end
+      end
+
+      def read_multi(*names)
+        options = names.extract_options!
+        options = merged_options(options)
+        results = {}
+        names.each do |name|
+          key = namespaced_key(name, options)
+          entry = read_entry(key, options)
+          if entry
+            if entry.expired?
+              delete_entry(key, options)
+            else
+              results[name] = entry.value
+            end
+          end
+        end
+        results
+      end
+
+      def fetch_multi(*names)
+        options = names.extract_options!
+        options = merged_options(options)
+        results = read_multi(*names, options)
+
+        names.each_with_object({}) do |name, memo|
+          memo[name] = results.fetch(name) do
+            value = yield name
+            write(name, value, options)
+            value
+          end
+        end
+      end
+
+      def write(name, value, options = nil)
+        options = merged_options(options)
+
+        instrument(:write, name, options) do
+          entry = Bizside::Cache::Entry.new(value, options)
+          write_entry(namespaced_key(name, options), entry, options)
+        end
+      end
+
+      def delete(name, options = nil)
+        options = merged_options(options)
+
+        instrument(:delete, name) do
+          delete_entry(namespaced_key(name, options), options)
+        end
+      end
+
+      def exist?(name, options = nil)
+        options = merged_options(options)
+
+        instrument(:exist?, name) do
+          entry = read_entry(namespaced_key(name, options), options)
+          (entry && !entry.expired?) || false
+        end
+      end
+
+      def delete_matched(matcher, options = nil)
+        raise NotImplementedError.new("does not support delete_matched")
+      end
+
+      def increment(name, amount = 1, options = nil)
+        raise NotImplementedError.new("does not support increment")
+      end
+
+      def decrement(name, amount = 1, options = nil)
+        raise NotImplementedError.new("does not support decrement")
+      end
+
+      def cleanup(options = nil)
+        raise NotImplementedError.new("does not support cleanup")
+      end
+
+      def clear(options = nil)
+        raise NotImplementedError.new("does not support clear")
+      end
+
+      protected
+      
+      def key_matcher(pattern, options)
+        prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]
+        if prefix
+          source = pattern.source
+          if source.start_with?('^')
+            source = source[1, source.length]
+          else
+            source = ".*#{source[0, source.length]}"
+          end
+          Regexp.new("^#{Regexp.escape(prefix)}:#{source}", pattern.options)
+        else
+          pattern
+        end
+      end
+
+      def read_entry(key, options)
+        raise NotImplementedError.new
+      end
+
+      def write_entry(key, entry, options)
+        raise NotImplementedError.new
+      end
+
+      def delete_entry(key, options)
+        raise NotImplementedError.new
+      end
+
+      private
+      
+      def merged_options(call_options)
+        if call_options
+          options.merge(call_options)
+        else
+          options.dup
+        end
+      end
+
+      def expanded_key(key)
+        return key.cache_key.to_s if key.respond_to?(:cache_key)
+
+        case key
+        when Array
+          if key.size > 1
+            key = key.collect{|element| expanded_key(element)}
+          else
+            key = key.first
+          end
+        when Hash
+          key = key.sort_by { |k,_| k.to_s }.collect{|k,v| "#{k}=#{v}"}
+        end
+
+        key.to_param
+      end
+
+      def namespaced_key(key, options)
+        key = expanded_key(key)
+        namespace = options[:namespace] if options
+        prefix = namespace.is_a?(Proc) ? namespace.call : namespace
+        key = "#{prefix}:#{key}" if prefix
+        key
+      end
+
+      def instrument(operation, key, options = nil)
+        payload = { :key => key }
+        payload.merge!(options) if options.is_a?(Hash)
+        ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload){ yield(payload) }
+      end
+
+      def find_cached_entry(key, name, options)
+        instrument(:read, name, options) do |payload|
+          payload[:super_operation] = :fetch if payload
+          read_entry(key, options)
+        end
+      end
+
+      def handle_expired_entry(entry, key, options)
+        if entry && entry.expired?
+          race_ttl = options[:race_condition_ttl].to_i
+          if (race_ttl > 0) && (Time.now.to_f - entry.expires_at <= race_ttl)
+            entry.expires_at = Time.now + race_ttl
+            write_entry(key, entry, :expires_in => race_ttl * 2)
+          else
+            delete_entry(key, options)
+          end
+          entry = nil
+        end
+        entry
+      end
+
+      def get_entry_value(entry, name, options)
+        instrument(:fetch_hit, name, options) { |payload| }
+        entry.value
+      end
+
+      def save_block_result_to_cache(name, options)
+        result = instrument(:generate, name, options) do |payload|
+          yield(name)
+        end
+
+        write(name, result, options)
+        result
+      end
+      
+    end
+  end
+end

data/lib/bizside/cache_util.rb

@@ -0,0 +1,47 @@
+module Bizside
+  module CacheUtil
+    
+    def fetch(key, options = {})
+      if block_given?
+        action = cache.exist?(key) ? 'READ' : 'WRITE'
+        output_log "#{action} CACHE: #{key}"
+        cache.fetch(key, options) do
+          yield
+        end
+      else
+        output_log "READ CACHE: #{key}" 
+        cache.fetch(key, options)
+      end
+    end
+
+    def delete(key)
+      output_log "CLEAR CACHE: #{key}"
+      cache.delete(key)
+    end
+
+    def delete_matched(matcher)
+      output_log "CLEAR CACHE: #{matcher}"
+      cache.delete_matched(matcher)
+    end
+
+    def clear(options = nil)
+      output_log "CLEAR ALL CACHE"
+      cache.clear(options)
+    end
+
+    def cache
+      raise 'サブクラスで実装'
+    end
+    
+    private
+    
+    def output_log message
+      if defined?(Rails) && Rails.logger
+        Rails.logger.info message
+      else
+        puts message
+      end
+    end
+
+  end
+end