aliyun-log 0.2.2 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b17c3b8727ec3dc44742d220f22f26014a201334889f888d858a0cbc33b9c39
-  data.tar.gz: df953904cf39fea58a11d99fab15ca115e3187667d062dfacec0a6f1301b2510
+  metadata.gz: 8c29e47df03c69ea213e48e43e272714f950887b5ab8efaa60321e4506b4d4bd
+  data.tar.gz: fd5dcd273e40f70f93bd69e1fc9dbc392171d90c9881650503c420b18cf0cd5d
 SHA512:
-  metadata.gz: dc5e4072953b2e687f7153230d23f3f6c6d68ac80abb52278819531cb6219eec1c0c9abf593e93d2b05dc697d74f6be75d94c522314088c416bb108631290bd7
-  data.tar.gz: 96b65f80b1fba4284d4472e524d8e424d58fff86ebac92cb281481af51134f8a75bb624d8339f67735038d3d36252bb4a6aa66bb3bc117c8706622a80eccefc1
+  metadata.gz: 6a4a990ac42f07d0ce44fe018604a5af553f5d53a74cdb0b3abfd9a6b15f891f434bc3fada83afdae815c3bbf5477d72be9520f6926609ec356fe9aa8b6098d5
+  data.tar.gz: 0addf200ac1e5328fd5fbd4a459cf756a52f0b8ad1bc53f775676340147af385dc8758da2b7b0d63c8285b409820e4ab8778a822d0505172d554e12865ad7567

data/lib/aliyun/log.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'version'
 require_relative 'log/common'
 require_relative 'log/client'
 require_relative 'log/config'

data/lib/aliyun/log/common/logging.rb

@@ -38,7 +38,7 @@ module Aliyun
         def self.logger
           unless @logger
             @logger = Logger.new(
-              @log_file ||= Config.log_file, MAX_NUM_LOG, ROTATE_SIZE
+              @log_file ||= Config.log_file || IO::NULL, MAX_NUM_LOG, ROTATE_SIZE
             )
             @logger.level = Logging.logger_level
           end

data/lib/aliyun/log/config.rb

@@ -7,8 +7,8 @@ module Aliyun
       @endpoint = 'https://cn-beijing.log.aliyuncs.com'
       @open_timeout = 10
       @read_timeout = 120
-      @log_file = 'aliyun_log.log'
-      @log_level = Logger::DEBUG
+      @log_level = Logger::WARN
+      @log_file = STDOUT
       @timestamps = true
       class << self
         attr_accessor :endpoint, :access_key_id, :access_key_secret,

data/lib/aliyun/log/logtail.rb

@@ -0,0 +1,13 @@
+module Aliyun
+	module Log
+		class LogTail < Common::AttrStruct
+			attrs :name, :log_type, :log_path, :file_pattern, :localstore, :time_format,
+						:log_begin_regex, :regex, :key, :topic_format,
+						:filterKey, :filter_regex, :file_encoding
+      def initialize(opts, protocol)
+        super(opts)
+        @protocol = protocol
+      end
+		end
+	end
+end

data/lib/aliyun/log/protocol.rb

@@ -108,7 +108,7 @@ module Aliyun
       def build_log_pb(attrs, time = Time.now.to_i)
         logs = attrs.is_a?(Array) ? attrs : [attrs]
         logs.map do |log_attr|
-          contents = log_attr.compact.map { |k, v| { key: k, value: v.to_s } }
+          contents = log_attr.map { |k, v| { key: k, value: v.to_s } }
           Protobuf::Log.new(time: time, contents: contents)
         end
       end
@@ -182,7 +182,7 @@ module Aliyun
           keys: {}
         }
         fields.each do |k, v|
-          v[:token] = INDEX_DEFAULT_TOKEN if %w[text json].include?(v[:type].to_s) && v[:token].blank?
+          v[:token] = INDEX_DEFAULT_TOKEN if %w[text json].include?(v[:type].to_s) && v[:token].nil?
           body[:keys][k] = v
         end
         @http.post({ project: project_name, logstore: logstore_name, action: 'index' }, body.to_json)
@@ -196,7 +196,7 @@ module Aliyun
           keys: {}
         }
         fields.each do |k, v|
-          v[:token] = INDEX_DEFAULT_TOKEN if %w[text json].include?(v[:type].to_s) && v[:token].blank?
+          v[:token] = INDEX_DEFAULT_TOKEN if %w[text json].include?(v[:type].to_s) && v[:token].nil?
           body[:keys][k] = v
         end
         @http.put({ project: project_name, logstore: logstore_name, action: 'index' }, body.to_json)

data/lib/aliyun/log/record.rb

@@ -9,7 +9,7 @@ require 'forwardable'
 require_relative 'record/exception'
 require_relative 'record/field'
 require_relative 'record/persistence'
-require_relative 'record/relation'
+require_relative 'record/scoping'
 
 module Aliyun
   module Log
@@ -27,45 +27,30 @@ module Aliyun
 
         Log.included_models << self unless Log.included_models.include? self
 
-        field :created_at, :text if Config.timestamps
+        field :created_at, type: :text, cast_type: :datetime if Config.timestamps
 
         define_model_callbacks :save, :create, :initialize
 
-        after_initialize :set_created_at
+        before_save :set_created_at
       end
 
       include Field
       include Persistence
+      include Scoping
 
       include ActiveModel::AttributeMethods
 
       module ClassMethods
         def logstore(options = {})
-          if options[:timestamps] && !Config.timestamps
+          opt = options.dup
+          if opt[:timestamps] && !Config.timestamps
             field :created_at, :text
-          elsif options[:timestamps] == false && Config.timestamps
+          elsif opt[:timestamps] == false && Config.timestamps
             remove_field :created_at
           end
-          self._schema_load = true if options[:auto_sync] == false
-          self.options = options
-        end
-
-        Relation.instance_methods(false).each do |method|
-          define_method(method) do |args|
-            relation.public_send(method, args)
-          end
-        end
-
-        %i[count load result].each do |method|
-          define_method(method) do
-            relation.public_send(method)
-          end
-        end
-
-        private
-
-        def relation
-          Relation.new(self)
+          self._schema_load = true if opt[:auto_sync] == false
+          opt[:field_doc_value] = opt[:field_doc_value] != false
+          self.options = opt
         end
       end
 
@@ -101,7 +86,7 @@ module Aliyun
                        end.compact.join(', ')
                      else
                        'not initialized'
-        end
+                     end
 
         "#<#{self.class} #{inspection}>"
       end

data/lib/aliyun/log/record/exception.rb

@@ -4,6 +4,7 @@ module Aliyun
       class ArgumentError < StandardError; end
       class UnknownAttributeError < StandardError; end
       class ProjectNameError < StandardError; end
+      class ParseStatementInvalid < StandardError; end
     end
   end
 end

data/lib/aliyun/log/record/field.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
-require "active_support"
-require "active_support/time"
-require "active_support/core_ext"
-require "active_model"
+
+require_relative 'type_casting'
 
 module Aliyun
   module Log
@@ -22,13 +20,16 @@ module Aliyun
 
         included do
           class_attribute :attributes, instance_accessor: false, default: {}
+          extend Common::Logging
         end
 
         module ClassMethods
-          def field(name, type = :text, options = {})
+          def field(name, options = {})
+            type = options[:type] || :text
             unless PERMITTED_KEY_TYPES.include?(type)
               raise ArgumentError, "Field #{name} type(#{type}) error, key type only support text/long/double/json"
             end
+
             named = name.to_s
             self.attributes = attributes.merge(name => { type: type }.merge(options))
 
@@ -36,7 +37,7 @@ module Aliyun
             warn_about_method_overriding("#{named}=", name)
             warn_about_method_overriding("#{named}?", name)
 
-            define_attribute_method(name) # Dirty API
+            define_attribute_method(name)
 
             generated_methods.module_eval do
               define_method(named) { read_attribute(named) }
@@ -64,7 +65,6 @@ module Aliyun
               remove_method field
               remove_method :"#{field}="
               remove_method :"#{field}?"
-              remove_method :"#{field}_before_type_cast"
             end
           end
 
@@ -80,7 +80,8 @@ module Aliyun
 
           def warn_about_method_overriding(method_name, field_name)
             if instance_methods.include?(method_name.to_sym)
-              Common::Logging.logger.warn("Method #{method_name} generated for the field #{field_name} overrides already existing method")
+              logger.warn("Method #{method_name} generated for the field #{field_name} " \
+                          'overrides already existing method')
             end
           end
         end
@@ -106,7 +107,7 @@ module Aliyun
         attr_accessor :attributes
 
         def write_attribute(name, value)
-          attributes[name.to_sym] = value
+          attributes[name.to_sym] = TypeCasting.cast_field(value, self.class.attributes[name.to_sym])
         end
 
         alias []= write_attribute
@@ -117,7 +118,7 @@ module Aliyun
         alias [] read_attribute
 
         def set_created_at
-          self.created_at ||= DateTime.now.in_time_zone(Time.zone).to_s if timestamps_enabled?
+          self.created_at ||= DateTime.now.in_time_zone(Time.zone).iso8601 if timestamps_enabled?
         end
 
         def timestamps_enabled?

data/lib/aliyun/log/record/persistence.rb

@@ -8,7 +8,8 @@ module Aliyun
 
         module ClassMethods
           def logstore_name
-            @logstore_name ||= options[:name] || base_class.name.split('::').last.downcase.pluralize
+            @logstore_name ||= options[:name] ||
+                               base_class.name.split('::').last.underscore.pluralize
           end
 
           def logstore_name=(value)
@@ -34,6 +35,7 @@ module Aliyun
           end
 
           def sync_index
+            return if field_indices.blank?
             has_index? ? update_index : create_index
           end
 
@@ -55,9 +57,8 @@ module Aliyun
           def create(data, opts = {})
             auto_load_schema
             if data.is_a?(Array)
-              logs = []
-              data.each do |log_attr|
-                logs << new(log_attr).save_array
+              logs = data.map do |log_attr|
+                new(log_attr).save_array
               end
               res = Log.record_connection.put_log(project_name, logstore_name, logs, opts)
               res.code == 200
@@ -79,10 +80,10 @@ module Aliyun
           end
 
           def field_indices
-            if options[:field_index] == true
-              attributes.reject { |_, value| value[:index] == false }
-            else
+            if options[:field_index] == false
               attributes.select { |_, value| value[:index] == true }
+            else
+              attributes.reject { |_, value| value[:index] == false }
             end
           end
 
@@ -97,18 +98,38 @@ module Aliyun
           def update_index
             conf_res = Log.record_connection.get_index(project_name, logstore_name)
             raw_conf = JSON.parse(conf_res)
-            index_conf = raw_conf.dup
-            field_indices.each do |k, v|
-              index_conf['keys'][k.to_s] ||= v
+            index_conf = raw_conf.deep_dup
+            field_index_types.each do |k, v|
+              index_conf['keys'][k.to_s] ||= {}
+              index_conf['keys'][k.to_s].merge!(v.as_json)
             end
             return if index_conf['keys'] == raw_conf['keys']
 
             Log.record_connection.update_index(
               project_name,
               logstore_name,
-              index_conf['keys']
+              index_conf['keys'].with_indifferent_access
             )
           end
+
+          def field_index_types
+            field_indices.tap do |tap|
+              tap.each do |_, v|
+                v[:alias] ||= ''
+                v[:caseSensitive] ||= false
+                v[:chn] ||= false
+                v[:doc_value] = options[:field_doc_value] != false if v[:doc_value].nil?
+              end
+            end
+          end
+        end
+
+        def dump_attributes
+          attributes.dup.tap do |tap|
+            tap.each do |k, v|
+              tap[k] = TypeCasting.dump_field(v, self.class.attributes[k])
+            end
+          end
         end
 
         def save
@@ -116,7 +137,11 @@ module Aliyun
           run_callbacks(:create) do
             run_callbacks(:save) do
               if valid?
-                res = Log.record_connection.put_log(self.class.project_name, self.class.logstore_name, attributes)
+                res = Log.record_connection.put_log(
+                  self.class.project_name,
+                  self.class.logstore_name,
+                  dump_attributes
+                )
                 res.code == 200
               else
                 false
@@ -128,7 +153,7 @@ module Aliyun
         def save_array
           run_callbacks(:create) do
             run_callbacks(:save) do
-              validate! && attributes
+              validate! && dump_attributes
             end
           end
         end

data/lib/aliyun/log/record/relation.rb

@@ -8,7 +8,63 @@ module Aliyun
           @klass = klass
           @opts = opts
           @klass.auto_load_schema
-          @opts[:search] ||= '*'
+        end
+
+        def inspect
+          "#<#{self.class}>"
+        end
+
+        def first(line = 1)
+          find_offset(0, line, false)
+        end
+
+        def second
+          find_offset(1)
+        end
+
+        def third
+          find_offset(2)
+        end
+
+        def fourth
+          find_offset(3)
+        end
+
+        def fifth
+          find_offset(4)
+        end
+
+        def last(line = 1)
+          data = find_offset(0, line, true)
+          line > 1 ? data.reverse : data
+        end
+
+        def find_offset(nth, line = 1, reverse = false)
+          # @opts[:select] = '*'
+          @opts[:line] = line
+          @opts[:offset] = nth
+          if @opts[:order].present? && reverse
+            conds = []
+            @opts[:order].split(',').each do |field|
+              field.gsub!(/\s+desc|asc.*/i, '')
+              conds << "#{field.strip} DESC"
+            end
+            @opts[:order] = conds.join(', ')
+          end
+          @opts[:order] ||= reverse ? '__time__ DESC' : '__time__ ASC'
+          if @opts[:select].blank?
+            line <= 1 ? load[0] : load
+          else
+            line <= 1 ? result[0] : result
+          end
+        end
+
+        def scoping
+          previous = @klass.current_scope
+          @klass.current_scope = self
+          yield
+        ensure
+          @klass.current_scope = previous
         end
 
         def from(from)
@@ -36,21 +92,67 @@ module Aliyun
 
         def page(val)
           @opts[:page] = val - 1 if val >= 1
+          singleton_class.send(:define_method, :total_count) do
+            @total_count ||= count
+          end
+          singleton_class.send(:define_method, :total_pages) do
+            (total_count.to_f / (@opts[:line] || 100)).ceil
+          end
           self
         end
 
-        def where(opts)
+        def api(opts)
           @opts.merge!(opts)
           self
         end
 
-        def search(str)
-          @opts[:search] = str
+        def search(*statement)
+          ql = statement_ql(*statement)
+          @opts[:search] = ql if ql.present?
           self
         end
 
-        def sql(str)
-          @opts[:sql] = str
+        def sql(*statement)
+          unless statement[0].is_a?(String)
+            raise ParseStatementInvalid, 'Only support string statement'
+          end
+          ql = sanitize_array(*statement)
+          @opts[:sql] = ql if ql.present?
+          self
+        end
+
+        def where(*statement)
+          if statement[0].is_a?(String)
+            ql = sanitize_array(*statement)
+            @opts[:where] = ql
+          else
+            ql = statement_ql(*statement)
+            @opts[:search] = ql
+          end
+          self
+        end
+
+        def select(*fields)
+          @opts[:select] = fields.join(', ')
+          self
+        end
+
+        def group(*fields)
+          @opts[:group] = fields.join(', ')
+          self
+        end
+
+        def order(*fields)
+          if fields[0].is_a?(Hash)
+            @opts[:order] = fields[0].map do |k, v|
+              unless %w[asc desc].include?(v.to_s)
+                raise ArgumentError, "Direction \"#{v}\" is invalid. Valid directions are: [:asc, :desc, :ASC, :DESC]" 
+              end
+              "#{k} #{v}"
+            end.join(', ')
+          else
+            @opts[:order] = fields.join(', ')
+          end
           self
         end
 
@@ -60,36 +162,193 @@ module Aliyun
         end
 
         def count
+          # @opts[:select] = 'COUNT(*) as count'
+          _sql = to_sql
+          sql = "SELECT COUNT(*) as count"
+          sql += " FROM(#{_sql})" if _sql.present?
           query = @opts.dup
-          if query[:query].blank?
-            where_cond = query[:sql].split(/where /i)[1] if query[:sql].present?
-            query[:query] = "#{query[:search]}|SELECT COUNT(*) as count"
-            query[:query] = "#{query[:query]} WHERE #{where_cond}" if where_cond.present?
-          end
-          res = Log.record_connection.get_logs(@klass.project_name, @klass.logstore_name, query)
-          res = JSON.parse(res.body)
-          res[0]['count'].to_i
+          query[:query] = "#{query[:search] || '*'}|#{sql}"
+          res = execute(query)
+          res.dig(0, 'count').to_i
+        end
+
+        def sum(field)
+          @opts[:select] = "SUM(#{field}) as sum"
+          query = @opts.dup
+          query[:query] = "#{query[:search] || '*'}|#{to_sql}"
+          res = execute(query)
+          res.dig(0, 'sum').to_f
         end
 
         def result
           query = @opts.dup
-          if query[:page]
-            query[:line] ||= 100
-            query[:offset] = query[:page] * query[:line]
+          query[:query] = query[:search] || '*'
+          sql = to_sql
+          if sql.present?
+            query[:query] += "|#{sql}"
+            @opts[:line] = nil
+            @opts[:offset] = nil
+            @opts[:page] = nil
           end
-          query[:query] = query[:search]
-          query[:query] = "#{query[:query]}|#{query[:sql]}" if query[:sql].present?
-          res = Log.record_connection.get_logs(@klass.project_name, @klass.logstore_name, query)
-          JSON.parse(res)
+          execute(query)
         end
 
         def load
           result.map do |json_attr|
-            attrs = {}
-            @klass.attributes.keys.each do |k, _|
-              attrs[k] = json_attr[k.to_s]
+            record = @klass.new
+            json_attr.each do |key, value|
+              record.send("#{key}=", value) if record.respond_to?("#{key}=")
             end
-            @klass.new(attrs)
+            record
+          end
+        end
+
+        def to_sql
+          opts = @opts.dup
+          sql_query = []
+          sql_query << "WHERE #{opts[:where]}" if opts[:where].present?
+          sql_query << "GROUP BY #{opts[:group]}" if opts[:group].present?
+          sql_query << "ORDER BY #{opts[:order]}" if opts[:order].present?
+          if sql_query.present? || opts[:select].present?
+            sql_query.insert(0, "SELECT #{opts[:select] || '*'}")
+            sql_query.insert(1, 'FROM log')
+            if opts[:line] || opts[:page] || opts[:offset]
+              parse_page
+              sql_query << "LIMIT #{@opts[:offset]},#{@opts[:line]}"
+            end
+          end
+          "#{opts[:query]}#{sql_query.join(' ')}"
+        end
+
+        private
+
+        def execute(query)
+          puts query.slice(:from, :to, :search, :query).to_json
+          res = Log.record_connection.get_logs(@klass.project_name, @klass.logstore_name, query)
+          JSON.parse(res)
+        end
+
+        def parse_page
+          @opts[:line] ||= 100
+          @opts[:page] ||= 0
+          @opts[:offset] = @opts[:page] * @opts[:line]
+        end
+
+        def statement_ql(*statement)
+          if statement.size == 1
+            sanitize_hash(statement.first)
+          elsif statement.size > 1
+            sanitize_array(*statement)
+          end
+        end
+
+        def sanitize_hash(search_content)
+          return search_content unless search_content.is_a?(Hash)
+
+          search_content.select { |_, v| v.present? }.map do |key, value|
+            options = @klass.attributes[:"#{key}"]
+            unless options
+              raise UnknownAttributeError, "unknown field '#{key}' for #{@klass.name}."
+            end
+
+            raise_if_hash_quote(value)
+
+            cast_type = options[:cast_type]
+            if value.is_a?(Array)
+              values = value.uniq.map { |v| _quote(cast_type, v) }
+              str_values = values.map { |v| "#{key}: #{v}" }.join(' OR ')
+              values.size > 1 ? "(#{str_values})" : str_values
+            elsif value.is_a?(Range)
+              "#{key} in [#{value.begin} #{value.end}]"
+            else
+              "#{key}: #{_quote(cast_type, value)}"
+            end
+          end.join(' AND ')
+        end
+
+        def sanitize_array(*ary)
+          statement, *values = ary
+          if values.first.is_a?(Hash) && /:\w+/.match?(statement)
+            replace_named_bind_variables(statement, values.first)
+          elsif statement.include?('?')
+            replace_bind_variables(statement, values)
+          elsif statement.blank? || values.blank?
+            statement
+          else
+            statement % values.collect(&:to_s)
+          end
+        end
+
+        def replace_named_bind_variables(statement, bind_vars)
+          statement.gsub(/(:?):([a-zA-Z]\w*)/) do |match|
+            if bind_vars.include?(match = Regexp.last_match(2).to_sym)
+              match_value = bind_vars[match]
+              raise_if_hash_quote(match_value)
+              if match_value.is_a?(Array) || match_value.is_a?(Range)
+                values = match_value.map { |v| _quote_type_value(v) }
+                values.join(', ')
+              else
+                _quote_type_value(match_value)
+              end
+            else
+              raise ParseStatementInvalid, "missing value for :#{match} in #{statement}"
+            end
+          end
+        end
+
+        def replace_bind_variables(statement, values)
+          expected = statement.count('?')
+          provided = values.size
+          if expected != provided
+            raise ParseStatementInvalid, "wrong number of bind variables (#{provided} " \
+                                         "for #{expected}) in: #{statement}"
+          end
+          bound = values.dup
+          statement.gsub(/\?/) do
+            value = bound.shift
+            raise_if_hash_quote(value)
+            if value.is_a?(Array) || value.is_a?(Range)
+              values = value.map { |v| _quote_type_value(v) }
+              values.join(', ')
+            else
+              _quote_type_value(value)
+            end
+          end
+        end
+
+        def _quote(type, value)
+          v = TypeCasting.cast_field(value, cast_type: type || :string)
+          case type
+          when :string, nil then "'#{v.to_s}'"
+          when :bigdecimal  then v.to_s("F")
+          when :integer     then v.to_s.to_i
+          when :datetime, :date then "'#{v.iso8601}'"
+          else
+            value.to_s
+          end
+        end
+
+        def _quote_type_value(value)
+          case value.class.name
+          when 'String'                   then "'#{value.to_s}'"
+          when 'BigDecimal', 'Float'      then value.to_s("F")
+          when 'Date', 'DateTime', 'Time' then "'#{value.iso8601}'"
+          else
+            value
+          end
+        end
+
+        def raise_if_hash_quote(value)
+          if value.is_a?(Hash) || value.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            raise ParseStatementInvalid, "can't quote Hash"
+          end
+        end
+
+        def method_missing(method, *args, &block)
+          if @klass.respond_to?(method)
+            scoping { @klass.public_send(method, *args, &block) }
+          else
+            super
           end
         end
       end

data/lib/aliyun/log/record/scope_registry.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Aliyun
+  module Log
+    module PerThreadRegistry
+      def self.extended(object)
+        object.instance_variable_set '@per_thread_registry_key', object.name.freeze
+      end
+
+      def instance
+        Thread.current[@per_thread_registry_key] ||= new
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        singleton_class.delegate name, to: :instance
+
+        send(name, *args, &block)
+      end
+    end
+
+    class ScopeRegistry
+      extend PerThreadRegistry
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      def value_for(scope_type, model)
+        @registry[scope_type][model.name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +model+.
+      def set_value_for(scope_type, model, value)
+        @registry[scope_type][model.name] = value
+      end
+    end
+  end
+end

data/lib/aliyun/log/record/scoping.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'scope_registry'
+require_relative 'relation'
+
+module Aliyun
+  module Log
+    module Record
+      module Scoping
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          delegate :load, :result, :count, :sum, to: :all
+          delegate :where, :query, :search, :sql, :from, :to, :api,
+                   :page, :line, :limit, :offset, :select, :group,
+                   :order, :to_sql, to: :all
+          delegate :first, :last, :second, :third, :fourth, :fifth, :find_offset, to: :all
+
+          def current_scope
+            ScopeRegistry.value_for(:current_scope, self)
+          end
+
+          def current_scope=(scope)
+            ScopeRegistry.set_value_for(:current_scope, self, scope)
+          end
+
+          def scope(name, body)
+            raise ArgumentError, 'The scope body needs to be callable.' unless body.respond_to?(:call)
+
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all
+              scope = scope.scoping { body.call(*args) }
+              scope
+            end
+          end
+
+          def unscoped
+            block_given? ? relation.scoping { yield } : relation
+          end
+
+          def all
+            scope = current_scope
+            scope ||= relation.from(0).to(Time.now.to_i)
+            scope
+          end
+
+          private
+
+          def relation
+            Relation.new(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/log/record/type_casting.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Aliyun
+  module Log
+    module Record
+      module TypeCasting
+        TYPE_MAPPING = {
+          text: :string,
+          long: :integer,
+          double: :float,
+          json: :json
+        }.freeze
+
+        def self.cast_field(value, options)
+          options ||= {}
+          type = options[:cast_type]
+          type ||= TYPE_MAPPING[options[:type]]
+
+          return value if options.nil?
+          return nil if value.nil?
+
+          caster = Registry.lookup(type)
+          raise ArgumentError, "Unknown type #{options[:type]}" if caster.nil?
+
+          caster.new(options).cast(value)
+        end
+
+        def self.dump_field(value, options)
+          options ||= {}
+          type = options[:cast_type]
+          type ||= TYPE_MAPPING[options[:type]]
+
+          return value if options.nil?
+          return nil if value.nil?
+
+          dumper = Registry.lookup(type)
+          raise ArgumentError, "Unknown type #{options[:type]}" if dumper.nil?
+
+          dumper.new(options).dump(value)
+        end
+
+        class Value
+          def initialize(options)
+            @options = options
+          end
+
+          def cast(value)
+            value
+          end
+
+          def dump(value)
+            value
+          end
+        end
+
+        class StringType < Value; end
+
+        class DateType < Value
+          def cast(value)
+            return nil unless value.respond_to?(:to_date)
+
+            value.to_date
+          end
+
+          def dump(value)
+            if value.respond_to?(:to_date)
+              value.to_date.to_s
+            else
+              value.to_s
+            end
+          end
+        end
+
+        class DateTimeType < Value
+          def cast(value)
+            return nil unless value.respond_to?(:to_datetime)
+
+            dt = begin
+                   ::DateTime.parse(value)
+                 rescue StandardError
+                   nil
+                 end
+            if dt
+              seconds = string_utc_offset(value) || 0
+              offset = seconds_to_offset(seconds)
+              ::DateTime.new(dt.year, dt.mon, dt.mday, dt.hour, dt.min, dt.sec, offset)
+            else
+              value.to_datetime
+            end
+          end
+
+          def dump(value)
+            if value.respond_to?(:to_datetime)
+              value.to_datetime.iso8601
+            else
+              value.to_s
+            end
+          end
+
+          private
+
+          def string_utc_offset(string)
+            Date._parse(string)[:offset]
+          end
+
+          def seconds_to_offset(seconds)
+            ActiveSupport::TimeZone.seconds_to_utc_offset(seconds)
+          end
+        end
+
+        class IntegerType < Value
+          def cast(value)
+            if value == true
+              1
+            elsif value == false
+              0
+            elsif value.is_a?(String) && value.blank?
+              nil
+            elsif value.is_a?(Float) && !value.finite?
+              nil
+            elsif !value.respond_to?(:to_i)
+              nil
+            else
+              value.to_i
+            end
+          end
+        end
+
+        class BigDecimalType < Value
+          def cast(value)
+            if value == true
+              1
+            elsif value == false
+              0
+            elsif value.is_a?(Symbol)
+              value.to_s.to_d
+            elsif value.is_a?(String) && value.blank?
+              nil
+            elsif value.is_a?(Float) && !value.finite?
+              nil
+            elsif !value.respond_to?(:to_d)
+              nil
+            else
+              value.to_d
+            end
+          end
+        end
+
+        class FloatType < Value
+          def cast(value)
+            if value == true
+              1
+            elsif value == false
+              0
+            elsif value.is_a?(Symbol)
+              value.to_s.to_f
+            elsif value.is_a?(String) && value.blank?
+              nil
+            elsif value.is_a?(Float) && !value.finite?
+              nil
+            elsif !value.respond_to?(:to_f)
+              nil
+            else
+              value.to_f
+            end
+          end
+        end
+
+        class JsonType < Value
+          def cast(value)
+            return value unless value.is_a?(String)
+
+            begin
+              ActiveSupport::JSON.decode(value)
+            rescue StandardError
+              nil
+            end
+          end
+
+          def dump(value)
+            ActiveSupport::JSON.encode(value) unless value.nil?
+          end
+        end
+
+        module Registry
+          module_function
+
+          @registrations = {}
+
+          def register(name, klass = nil)
+            @registrations[name.to_sym] = klass
+          end
+
+          def lookup(name)
+            name ||= :string
+            @registrations[name.to_sym]
+          end
+
+          register(:string, StringType)
+          register(:date, DateType)
+          register(:datetime, DateTimeType)
+          register(:bigdecimal, BigDecimalType)
+          register(:integer, IntegerType)
+          register(:float, FloatType)
+          register(:json, JsonType)
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/log/request.rb

@@ -83,7 +83,7 @@ module Aliyun
         end
 
         logger.debug("Received HTTP response, code: #{response.code}, headers: " \
-                      "#{response.headers}, body: #{response.body}")
+                      "#{response.headers}, body: #{response.body.force_encoding('UTF-8')}")
 
         response
       end

data/lib/aliyun/version.rb

@@ -2,6 +2,6 @@
 
 module Aliyun
   module Log
-    VERSION = '0.2.2'
+    VERSION = '0.2.11'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aliyun-log
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.11
 platform: ruby
 authors:
 - Yingce Liu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-09 00:00:00.000000000 Z
+date: 2020-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -128,6 +128,7 @@ files:
 - lib/aliyun/log/common/logging.rb
 - lib/aliyun/log/config.rb
 - lib/aliyun/log/logstore.rb
+- lib/aliyun/log/logtail.rb
 - lib/aliyun/log/project.rb
 - lib/aliyun/log/protobuf.rb
 - lib/aliyun/log/protocol.rb
@@ -136,6 +137,9 @@ files:
 - lib/aliyun/log/record/field.rb
 - lib/aliyun/log/record/persistence.rb
 - lib/aliyun/log/record/relation.rb
+- lib/aliyun/log/record/scope_registry.rb
+- lib/aliyun/log/record/scoping.rb
+- lib/aliyun/log/record/type_casting.rb
 - lib/aliyun/log/request.rb
 - lib/aliyun/log/server_error.rb
 - lib/aliyun/version.rb