prefab-cloud-ruby 0 → 0.0.1

data/lib/prefab/internal_logger.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Prefab
-  class InternalLogger < StaticLogger
-    INTERNAL_PREFIX = 'cloud.prefab.client'
-
-    def initialize(path)
-      if path.is_a?(Class)
-        path_string = path.name.split('::').last.downcase
-      else
-        path_string = path
-      end
-      super("#{INTERNAL_PREFIX}.#{path_string}")
-    end
-  end
-end

data/lib/prefab/local_config_parser.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module Prefab
-  class LocalConfigParser
-    class << self
-      def parse(key, value, config, file)
-        if value.instance_of?(Hash)
-          if value['feature_flag']
-            config[key] = feature_flag_config(file, key, value)
-          elsif value['type'] == 'provided'
-            config[key] = provided_config(file, key, value)
-          elsif value['decrypt_with'] || value['confidential']
-            config[key] = complex_string(file, key, value)
-          else
-            value.each do |nest_key, nest_value|
-              nested_key = "#{key}.#{nest_key}"
-              nested_key = key if nest_key == '_'
-              parse(nested_key, nest_value, config, file)
-            end
-          end
-        else
-          config[key] = {
-            source: file,
-            match: 'default',
-            config: PrefabProto::Config.new(
-              config_type: :CONFIG,
-              key: key,
-              rows: [
-                PrefabProto::ConfigRow.new(values: [
-                  PrefabProto::ConditionalValue.new(value: value_from(key, value))
-                ])
-              ]
-            )
-          }
-        end
-
-        config
-      end
-
-      def value_from(key, raw)
-        case raw
-        when String
-          if key.to_s.start_with? Prefab::LoggerClient::BASE_KEY
-            prefab_log_level_resolve = PrefabProto::LogLevel.resolve(raw.upcase.to_sym) || PrefabProto::LogLevel::NOT_SET_LOG_LEVEL
-            { log_level: prefab_log_level_resolve }
-          else
-            { string: raw }
-          end
-        when Integer
-          { int: raw }
-        when TrueClass, FalseClass
-          { bool: raw }
-        when Float
-          { double: raw }
-        end
-      end
-
-      def feature_flag_config(file, key, value)
-        criterion = (parse_criterion(value['criterion']) if value['criterion'])
-
-        variant = PrefabProto::ConfigValue.new(value_from(key, value['value']))
-
-        row = PrefabProto::ConfigRow.new(
-          values: [
-            PrefabProto::ConditionalValue.new(
-              criteria: [criterion].compact,
-              value: variant
-            )
-          ]
-        )
-
-        raise Prefab::Error, "Feature flag config `#{key}` #{file} must have a `value`" unless value.key?('value')
-
-        {
-          source: file,
-          match: key,
-          config: PrefabProto::Config.new(
-            config_type: :FEATURE_FLAG,
-            key: key,
-            allowable_values: [variant],
-            rows: [row]
-          )
-        }
-      end
-
-      def provided_config(file, key, value_hash)
-        value = PrefabProto::ConfigValue.new(provided: PrefabProto::Provided.new(
-          source: :ENV_VAR,
-          lookup: value_hash["lookup"],
-        ),
-                                             confidential: value_hash["confidential"],
-        )
-
-        row = PrefabProto::ConfigRow.new(
-          values: [
-            PrefabProto::ConditionalValue.new(
-              value: value
-            )
-          ]
-        )
-
-        {
-          source: file,
-          match: value.provided.lookup,
-          config: PrefabProto::Config.new(
-            config_type: :CONFIG,
-            key: key,
-            rows: [row]
-          )
-        }
-      end
-
-      def complex_string(file, key, value_hash)
-        value = PrefabProto::ConfigValue.new(
-          string: value_hash["value"],
-          confidential: value_hash["confidential"],
-          decrypt_with: value_hash["decrypt_with"],
-        )
-
-        row = PrefabProto::ConfigRow.new(
-          values: [
-            PrefabProto::ConditionalValue.new(
-              value: value
-            )
-          ]
-        )
-
-        {
-          source: file,
-          config: PrefabProto::Config.new(
-            config_type: :CONFIG,
-            key: key,
-            rows: [row]
-          )
-        }
-      end
-
-      def parse_criterion(criterion)
-        PrefabProto::Criterion.new(operator: criterion['operator'],
-                                   property_name: criterion['property'],
-                                   value_to_match: parse_value_to_match(criterion['values']))
-      end
-
-      def parse_value_to_match(values)
-        raise "Can't handle #{values}" unless values.instance_of?(Array)
-
-        PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: values))
-      end
-    end
-  end
-end

data/lib/prefab/log_path_aggregator.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'periodic_sync'
-
-module Prefab
-  class LogPathAggregator
-    LOG = Prefab::InternalLogger.new(LogPathAggregator)
-
-    include Prefab::PeriodicSync
-
-    INCREMENT = ->(count) { (count || 0) + 1 }
-
-    SEVERITY_KEY = {
-      ::Logger::DEBUG => 'debugs',
-      ::Logger::INFO => 'infos',
-      ::Logger::WARN => 'warns',
-      ::Logger::ERROR => 'errors',
-      ::Logger::FATAL => 'fatals'
-    }.freeze
-
-    attr_reader :data
-
-    def initialize(client:, max_paths:, sync_interval:)
-      @max_paths = max_paths
-      @client = client
-      @name = 'log_path_aggregator'
-
-      @data = Concurrent::Map.new
-
-      @last_data_sent = nil
-      @last_request = nil
-
-      start_periodic_sync(sync_interval)
-    end
-
-    def push(path, severity)
-      return if @data.size >= @max_paths
-
-      @data.compute([path, severity], &INCREMENT)
-    end
-
-    private
-
-    def flush(to_ship, start_at_was)
-      pool.post do
-        LOG.debug "Uploading stats for #{to_ship.size} paths"
-
-        aggregate = Hash.new { |h, k| h[k] = PrefabProto::Logger.new }
-
-        to_ship.each do |(path, severity), count|
-          aggregate[path][SEVERITY_KEY[severity]] = count
-          aggregate[path]['logger_name'] = path
-        end
-
-        loggers = PrefabProto::Loggers.new(
-          loggers: aggregate.values,
-          start_at: start_at_was,
-          end_at: Prefab::TimeHelpers.now_in_ms,
-          instance_hash: @client.instance_hash,
-          namespace: @client.namespace
-        )
-
-        result = post('/api/v1/known-loggers', loggers)
-
-        LOG.debug "Uploaded #{to_ship.size} paths: #{result.status}"
-      end
-    end
-  end
-end

data/lib/prefab/logger_client.rb

@@ -1,264 +0,0 @@
-# frozen_string_literal: true
-
-module Prefab
-  class LoggerClient < ::Logger
-    SEP = '.'
-    BASE_KEY = 'log-level'
-    UNKNOWN_PATH = 'unknown.'
-    LOG_TAGS = 'log.tags'
-    REQ_TAGS = 'req.tags'
-
-    LOG_LEVEL_LOOKUPS = {
-      PrefabProto::LogLevel::NOT_SET_LOG_LEVEL => ::Logger::DEBUG,
-      PrefabProto::LogLevel::TRACE => ::Logger::DEBUG,
-      PrefabProto::LogLevel::DEBUG => ::Logger::DEBUG,
-      PrefabProto::LogLevel::INFO => ::Logger::INFO,
-      PrefabProto::LogLevel::WARN => ::Logger::WARN,
-      PrefabProto::LogLevel::ERROR => ::Logger::ERROR,
-      PrefabProto::LogLevel::FATAL => ::Logger::FATAL
-    }.freeze
-
-    def self.instance
-      @@shared_instance ||= LoggerClient.new($stdout)
-    end
-
-    def initialize(logdev, log_path_aggregator: nil, formatter: Options::DEFAULT_LOG_FORMATTER, prefix: nil)
-      super(logdev)
-      self.formatter = Prefab::Logging::FormatterBase.new(formatter_proc: formatter, logger_client: self)
-      @config_client = BootstrappingConfigClient.new
-      @silences = Concurrent::Map.new(initial_capacity: 2)
-      @recurse_check = Concurrent::Map.new(initial_capacity: 2)
-      @prefix = "#{prefix}#{prefix && '.'}"
-
-      @context_keys_map = Concurrent::Map.new(initial_capacity: 4)
-
-      @log_path_aggregator = log_path_aggregator
-      @@shared_instance = self
-    end
-
-    def add_context_keys(*keys)
-      context_keys.merge(keys)
-    end
-
-    def with_context_keys(*keys)
-      context_keys.merge(keys)
-      yield
-    ensure
-      context_keys.subtract(keys)
-    end
-
-    def internal_logger(path = nil)
-      InternalLogger.new(path, self)
-    end
-
-    def context_keys
-      @context_keys_map.fetch_or_store(local_log_id, Concurrent::Set.new)
-    end
-
-    # InternalLoggers Will Call This
-    def add_internal(severity, message, progname, loc, log_context = {}, &block)
-      path_loc = get_loc_path(loc)
-      path = @prefix + path_loc
-
-      log(message, path, progname, severity, log_context, &block)
-    end
-
-    def log_internal(severity, message, path, log_context = {}, &block)
-      return if @recurse_check[local_log_id]
-      @recurse_check[local_log_id] = true
-      begin
-        log(message, path, nil, severity, log_context, &block)
-      ensure
-        @recurse_check[local_log_id] = false
-      end
-    end
-
-    def log(message, path, progname, severity, log_context = {})
-      severity ||= ::Logger::UNKNOWN
-
-      return true if !should_log? severity, path
-      return true if @logdev.nil? || @silences[local_log_id]
-
-      progname = @progname if progname.nil?
-
-      if message.nil?
-        if block_given?
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      @logdev.write(
-        format_message(format_severity(severity), Time.now, progname, message, path, stringify_keys(log_context.merge(fetch_context_for_context_keys)))
-      )
-      true
-    end
-
-    def should_log?(severity, path)
-      @log_path_aggregator&.push(path, severity)
-      severity >= level_of(path)
-    end
-
-    def debug(progname = nil, **log_context, &block)
-      add_internal(DEBUG, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def info(progname = nil, **log_context, &block)
-      add_internal(INFO, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def warn(progname = nil, **log_context, &block)
-      add_internal(WARN, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def error(progname = nil, **log_context, &block)
-      add_internal(ERROR, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def fatal(progname = nil, **log_context, &block)
-      add_internal(FATAL, nil, progname, caller_locations(1, 1)[0], log_context, &block)
-    end
-
-    def debug?
-      true
-    end
-
-    def info?
-      true
-    end
-
-    def warn?
-      true
-    end
-
-    def error?
-      true
-    end
-
-    def fatal?
-      true
-    end
-
-    def level
-      DEBUG
-    end
-
-    def tagged(*tags)
-      to_add = tags.flatten.compact
-      if block_given?
-        new_log_tags = current_tags
-        new_log_tags += to_add unless to_add.empty?
-        Prefab::Context.with_merged_context({ "log" => { "tags" => new_log_tags } }) do
-          with_context_keys LOG_TAGS do
-            yield self
-          end
-        end
-      else
-        new_log_tags = Prefab::Context.current.get(REQ_TAGS) || []
-        new_log_tags += to_add unless to_add.empty?
-        add_context_keys REQ_TAGS
-        Prefab::Context.current.set("req", {"tags": new_log_tags})
-        self
-      end
-    end
-
-    def current_tags
-      Prefab::Context.current.get(LOG_TAGS) || []
-    end
-
-    def flush
-      Prefab::Context.current.set("req", {"tags": nil})
-      super if defined?(super)
-    end
-
-    def config_client=(config_client)
-      @config_client = config_client
-    end
-
-    def local_log_id
-      Thread.current.__id__
-    end
-
-    def silence
-      @silences[local_log_id] = true
-      yield self
-    ensure
-      @silences[local_log_id] = false
-    end
-
-    private
-
-    NO_DEFAULT = nil
-
-    def stringify_keys(hash)
-      Hash[hash.map { |k, v| [k.to_s, v] }]
-    end
-
-    def fetch_context_for_context_keys
-      context = Prefab::Context.current.to_h
-      Hash[context_keys.map do |key|
-        [key, context.dig(*key.split("."))]
-      end]
-    end
-
-    # Find the closest match to 'log_level.path' in config
-    def level_of(path)
-      closest_log_level_match = nil
-
-      path.split(SEP).each_with_object([BASE_KEY]) do |n, memo|
-        memo << n
-        val = @config_client.get(memo.join(SEP), NO_DEFAULT)
-        closest_log_level_match = val unless val.nil?
-      end
-
-      if closest_log_level_match.nil?
-        # get the top-level setting or default to WARN
-        closest_log_level_match = @config_client.get(BASE_KEY, :WARN)
-      end
-
-      closest_log_level_match_int = PrefabProto::LogLevel.resolve(closest_log_level_match)
-      LOG_LEVEL_LOOKUPS[closest_log_level_match_int]
-    end
-
-    def get_loc_path(loc)
-      loc_path = loc.absolute_path || loc.to_s
-      get_path(loc_path, loc.base_label)
-    end
-
-    # sanitize & clean the path of the caller so the key
-    # looks like log_level.app.models.user
-    def get_path(absolute_path, base_label)
-      path = (absolute_path || UNKNOWN_PATH).dup
-      path.slice! Dir.pwd
-      path.gsub!(%r{(.*)?(?=/lib)}im, '') # replace everything before first lib
-
-      path = path.gsub('/', SEP).gsub(/.rb.*/, '') + SEP + base_label
-      path.slice! '.lib'
-      path.slice! SEP
-      path
-    end
-
-    def format_message(severity, datetime, progname, msg, path = nil, log_context = {})
-      formatter = (@formatter || @default_formatter)
-      compact_context = log_context.reject{ |_, v| v.nil? || ((v.is_a? Array) && v.empty?) }
-      @formatter.call_proc(
-        severity: severity,
-        datetime: datetime,
-        progname: progname,
-        path: path,
-        message: msg,
-        log_context: compact_context
-      )
-    end
-  end
-
-  # StubConfigClient to be used while config client initializes
-  # since it may log
-  class BootstrappingConfigClient
-    def get(_key, default = nil, _properties = {})
-      ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].upcase.to_sym : default
-    end
-  end
-end

data/lib/prefab/murmer3.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class Murmur3
-  ## MurmurHash3 was written by Austin Appleby, and is placed in the public
-  ## domain. The author hereby disclaims copyright to this source code.
-
-  MASK32 = 0xffffffff
-
-  def self.murmur3_32_rotl(x, r)
-    ((x << r) | (x >> (32 - r))) & MASK32
-  end
-
-  def self.murmur3_32_fmix(h)
-    h &= MASK32
-    h ^= h >> 16
-    h = (h * 0x85ebca6b) & MASK32
-    h ^= h >> 13
-    h = (h * 0xc2b2ae35) & MASK32
-    h ^ (h >> 16)
-  end
-
-  def self.murmur3_32__mmix(k1)
-    k1 = (k1 * 0xcc9e2d51) & MASK32
-    k1 = murmur3_32_rotl(k1, 15)
-    (k1 * 0x1b873593) & MASK32
-  end
-
-  def self.murmur3_32(str, seed = 0)
-    h1 = seed
-    numbers = str.unpack('V*C*')
-    tailn = str.length % 4
-    tail = numbers.slice!(numbers.size - tailn, tailn)
-    for k1 in numbers
-      h1 ^= murmur3_32__mmix(k1)
-      h1 = murmur3_32_rotl(h1, 13)
-      h1 = (h1 * 5 + 0xe6546b64) & MASK32
-    end
-
-    unless tail.empty?
-      k1 = 0
-      tail.reverse_each do |c1|
-        k1 = (k1 << 8) | c1
-      end
-      h1 ^= murmur3_32__mmix(k1)
-    end
-
-    h1 ^= str.length
-    murmur3_32_fmix(h1)
-  end
-end