aliyun-log 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0af7f849c9e5e9e6d59647f4b184c994977407f5b970f5d867505062401621c7
-  data.tar.gz: bfd3fafdac4839ac11d428638d44d15a4126d283195ddd6e5b033238f3e7b034
+  metadata.gz: 5b17c3b8727ec3dc44742d220f22f26014a201334889f888d858a0cbc33b9c39
+  data.tar.gz: df953904cf39fea58a11d99fab15ca115e3187667d062dfacec0a6f1301b2510
 SHA512:
-  metadata.gz: 033ae7fd59ab6e49b40c071942f289623226ca9a506f88cec0eafdce2edabcc56c5b2daecd7f7c8a6e27df39c11ebf62deab06c3d11b175c4b1f7eeef5284f5f
-  data.tar.gz: f31dc59e00955ecc7b0f6682356005b7ea2b872527818ea352418a99ddd81a8d3b0fd4d66f7fbda9c92073d9e8d51eca38b7af11364f2bf2d359ad565ac0299b
+  metadata.gz: dc5e4072953b2e687f7153230d23f3f6c6d68ac80abb52278819531cb6219eec1c0c9abf593e93d2b05dc697d74f6be75d94c522314088c416bb108631290bd7
+  data.tar.gz: 96b65f80b1fba4284d4472e524d8e424d58fff86ebac92cb281481af51134f8a75bb624d8339f67735038d3d36252bb4a6aa66bb3bc117c8706622a80eccefc1

data/lib/aliyun/log.rb

@@ -1,4 +1,5 @@
-# 
+# frozen_string_literal: true
+
 require_relative 'log/common'
 require_relative 'log/client'
 require_relative 'log/config'
@@ -8,11 +9,33 @@ require_relative 'log/protobuf'
 require_relative 'log/protocol'
 require_relative 'log/request'
 require_relative 'log/server_error'
+require_relative 'log/record'
 
 module Aliyun
   module Log
-    def self.configure
+    extend self
+
+    def configure
       block_given? ? yield(Config) : Config
     end
+    alias config configure
+
+    def included_models
+      @included_models ||= []
+    end
+
+    def record_connection
+      unless @record_connection
+        @record_connection = Protocol.new(Config.new)
+      end
+      @record_connection
+    end
+
+    def init_logstore
+      @included_models.each do |model|
+        model.create_logstore
+        modle.sync_index
+      end
+    end
   end
 end

data/lib/aliyun/log/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aliyun
   module Log
     class Client
@@ -10,6 +12,10 @@ module Aliyun
         @protocol.list_projects(size, offset)
       end
 
+      def projects(size = nil, offset = nil)
+        @protocol.projects(size, offset)
+      end
+
       def get_project(name)
         @protocol.get_project(name)
       end
@@ -25,6 +31,10 @@ module Aliyun
       def delete_project(name)
         @protocol.delete_project(name)
       end
+
+      def get_logstore(project_name, logstore_name)
+        @protocol.get_logstore(project_name, logstore_name)
+      end
     end
   end
 end

data/lib/aliyun/log/common.rb

@@ -1,3 +1,4 @@
-# 
+# frozen_string_literal: true
+
 require_relative 'common/attr_struct'
 require_relative 'common/logging'

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aliyun
   module Log
     module Common

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

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 module Aliyun
   module Log
     module Common
       module Logging
-        # DEFAULT_LOG_FILE = './log/aliyun_log.log'.freeze
-        DEFAULT_LOG_FILE = STDOUT
         MAX_NUM_LOG = 100
         ROTATE_SIZE = 10 * 1024 * 1024
 
@@ -15,15 +15,32 @@ module Aliyun
 
         # level = Logger::DEBUG | Logger::INFO | Logger::ERROR | Logger::FATAL
         def self.log_level=(level)
+          @logger_level = level
           Logging.logger.level = level
         end
 
+        def self.logger=(logger)
+          @logger = logger
+        end
+
+        def self.log_file=(log_file)
+          @logger = Logger.new(
+            log_file, MAX_NUM_LOG, ROTATE_SIZE
+          )
+          @logger.level = Logging.logger_level
+        end
+
+        def self.logger_level
+          @logger_level ||= Config.log_level
+          @logger_level
+        end
+
         def self.logger
           unless @logger
             @logger = Logger.new(
-              @log_file ||= DEFAULT_LOG_FILE, MAX_NUM_LOG, ROTATE_SIZE
+              @log_file ||= Config.log_file, MAX_NUM_LOG, ROTATE_SIZE
             )
-            @logger.level = Logger::DEBUG
+            @logger.level = Logging.logger_level
           end
           @logger
         end

data/lib/aliyun/log/config.rb

@@ -1,12 +1,19 @@
+# frozen_string_literal: true
+
+require 'logger'
 module Aliyun
   module Log
     class Config < Common::AttrStruct
       @endpoint = 'https://cn-beijing.log.aliyuncs.com'
       @open_timeout = 10
       @read_timeout = 120
+      @log_file = 'aliyun_log.log'
+      @log_level = Logger::DEBUG
+      @timestamps = true
       class << self
         attr_accessor :endpoint, :access_key_id, :access_key_secret,
-                      :open_timeout, :read_timeout
+                      :open_timeout, :read_timeout, :log_file, :log_level,
+                      :timestamps, :project
 
         def configure
           yield self
@@ -24,20 +31,19 @@ module Aliyun
         @access_key_secret ||= self.class.access_key_secret
         @endpoint ||= self.class.endpoint
         normalize_endpoint
+        raise 'Missing AccessKeyID or AccessKeySecret' if @access_key_id.nil? || @access_key_secret.nil?
       end
 
       private
 
-        def normalize_endpoint
-          uri = URI.parse(endpoint)
-          uri = URI.parse("http://#{endpoint}") unless uri.scheme
+      def normalize_endpoint
+        uri = URI.parse(endpoint)
+        uri = URI.parse("http://#{endpoint}") unless uri.scheme
 
-          if (uri.scheme != 'http') && (uri.scheme != 'https')
-            raise 'Only HTTP and HTTPS endpoint are accepted.'
-          end
+        raise 'Only HTTP and HTTPS endpoint are accepted.' if (uri.scheme != 'http') && (uri.scheme != 'https')
 
-          @endpoint = uri.to_s
-        end
+        @endpoint = uri.to_s
+      end
     end
   end
 end

data/lib/aliyun/log/logstore.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Aliyun
   module Log
     class Logstore < Common::AttrStruct
-
       attrs :name, :project_name, :ttl, :shared_count, :enable_tracking,
             :auto_split, :max_split_shard, :create_time, :last_modify_time
 
@@ -29,13 +30,7 @@ module Aliyun
       end
 
       def put_log(attributes)
-        contents = attributes.map { |k, v| { key: k.to_s, value: v.to_s } }
-        log = Aliyun::Log::Protobuf::Log.new(
-          time: Time.now.to_i,
-          contents: contents
-        )
-        log_group = Aliyun::Log::Protobuf::LogGroup.new(logs: [log])
-        put_logs(log_group)
+        @protocol.put_log(project_name, name, attributes)
       end
 
       def get_logs(opts = {})

data/lib/aliyun/log/project.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aliyun
   module Log
     class Project < Common::AttrStruct

data/lib/aliyun/log/protobuf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'protobuf'
 
 module Aliyun

data/lib/aliyun/log/protocol.rb

@@ -5,6 +5,7 @@ require 'json'
 module Aliyun
   module Log
     class Protocol
+      include Common::Logging
       def initialize(config)
         @http = Request.new(config)
       end
@@ -22,6 +23,10 @@ module Aliyun
         data
       end
 
+      def projects(size = nil, offset = nil)
+        list_projects(size, offset)['projects']
+      end
+
       def get_project(project_name)
         query = { projectName: project_name }
         attrs = @http.get({ project: project_name }, query)
@@ -61,7 +66,7 @@ module Aliyun
 
       def create_logstore(project_name, logstore_name, opt = {})
         body = {
-          logstore_name: logstore_name,
+          logstoreName: logstore_name,
           ttl: opt[:ttl] || 365,
           shardCount: opt[:shard_count] || 2,
           autoSplit: opt[:auto_split].nil? ? false : opt[:auto_split],
@@ -100,10 +105,17 @@ module Aliyun
         @http.post({ project: project_name, logstore: logstore_name, is_pb: true }, content)
       end
 
-      def put_log(project_name, logstore_name, log_attr)
-        contents = log_attr.compact.map { |k, v| { key: k, value: v } }
-        log_pb = Protobuf::Log.new(time: Time.now.to_i, contents: contents)
-        lg_pb = Protobuf::LogGroup.new(logs: [log_pb])
+      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 } }
+          Protobuf::Log.new(time: time, contents: contents)
+        end
+      end
+
+      def put_log(project_name, logstore_name, logs, opts = {})
+        logs = build_log_pb(logs, opts[:time] || Time.now.to_i)
+        lg_pb = Protobuf::LogGroup.new(logs: logs, topic: opts[:topic])
         @http.post({ project: project_name, logstore: logstore_name, is_pb: true }, lg_pb)
       end
 
@@ -170,10 +182,8 @@ 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?
           body[:keys][k] = v
-          if %w[text json].include?(v[:type]) && v[:token].blank?
-            v[:token] = INDEX_DEFAULT_TOKEN
-          end
         end
         @http.post({ project: project_name, logstore: logstore_name, action: 'index' }, body.to_json)
       end
@@ -186,10 +196,8 @@ 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?
           body[:keys][k] = v
-          if v[:type] == 'text' && v[:token].blank?
-            v[:token] = INDEX_DEFAULT_TOKEN
-          end
         end
         @http.put({ project: project_name, logstore: logstore_name, action: 'index' }, body.to_json)
       end

data/lib/aliyun/log/record.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/time'
+require 'active_support/core_ext'
+require 'active_model'
+require 'forwardable'
+
+require_relative 'record/exception'
+require_relative 'record/field'
+require_relative 'record/persistence'
+require_relative 'record/relation'
+
+module Aliyun
+  module Log
+    module Record
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations
+
+        class_attribute :options, instance_accessor: false, default: {}
+        class_attribute :base_class, instance_accessor: false, default: self
+        class_attribute :log_connection, instance_accessor: false
+        class_attribute :_schema_load, default: false
+
+        Log.included_models << self unless Log.included_models.include? self
+
+        field :created_at, :text if Config.timestamps
+
+        define_model_callbacks :save, :create, :initialize
+
+        after_initialize :set_created_at
+      end
+
+      include Field
+      include Persistence
+
+      include ActiveModel::AttributeMethods
+
+      module ClassMethods
+        def logstore(options = {})
+          if options[:timestamps] && !Config.timestamps
+            field :created_at, :text
+          elsif options[: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)
+        end
+      end
+
+      def initialize(attrs = {})
+        run_callbacks :initialize do
+          @new_record = true
+          @attributes ||= {}
+
+          attrs_with_defaults = self.class.attributes.each_with_object({}) do |(attribute, options), res|
+            res[attribute] = if attrs.key?(attribute)
+                               attrs[attribute]
+                             elsif options.key?(:default)
+                               evaluate_default_value(options[:default])
+                             end
+          end
+
+          attrs_virtual = attrs.slice(*(attrs.keys - self.class.attributes.keys))
+
+          attrs_with_defaults.merge(attrs_virtual).each do |key, value|
+            if respond_to?("#{key}=")
+              send("#{key}=", value)
+            else
+              raise UnknownAttributeError, "unknown attribute '#{key}' for #{@record.class}."
+            end
+          end
+        end
+      end
+
+      def inspect
+        inspection = if defined?(@attributes) && @attributes
+                       self.class.attributes.keys.collect do |name|
+                         "#{name}: #{attribute_for_inspect(name)}" if has_attribute?(name)
+                       end.compact.join(', ')
+                     else
+                       'not initialized'
+        end
+
+        "#<#{self.class} #{inspection}>"
+      end
+
+      def attribute_for_inspect(attr_name)
+        value = read_attribute(attr_name)
+
+        if value.is_a?(String) && value.length > 50
+          "#{value[0, 50]}...".inspect
+        elsif value.is_a?(Date) || value.is_a?(Time)
+          %("#{value.to_s(:db)}")
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Aliyun
+  module Log
+    module Record
+      class ArgumentError < StandardError; end
+      class UnknownAttributeError < StandardError; end
+      class ProjectNameError < StandardError; end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+require "active_support"
+require "active_support/time"
+require "active_support/core_ext"
+require "active_model"
+
+module Aliyun
+  module Log
+    module Record
+      module Field
+        extend ActiveSupport::Concern
+
+        # Types allowed in indexes:
+        PERMITTED_KEY_TYPES = %i[
+          text
+          long
+          double
+          json
+        ].freeze
+
+        DEFAULT_INDEX_TOKEN = ", '\";=()[]{}?@&<>/:\n\t\r".split('')
+
+        included do
+          class_attribute :attributes, instance_accessor: false, default: {}
+        end
+
+        module ClassMethods
+          def field(name, type = :text, options = {})
+            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))
+
+            warn_about_method_overriding(name, name)
+            warn_about_method_overriding("#{named}=", name)
+            warn_about_method_overriding("#{named}?", name)
+
+            define_attribute_method(name) # Dirty API
+
+            generated_methods.module_eval do
+              define_method(named) { read_attribute(named) }
+              define_method("#{named}?") do
+                value = read_attribute(named)
+                case value
+                when true        then true
+                when false, nil  then false
+                else
+                  !value.nil?
+                end
+              end
+              define_method("#{named}=") { |value| write_attribute(named, value) }
+            end
+          end
+
+          def remove_field(field)
+            field = field.to_sym
+            attributes.delete(field) || raise('No such field')
+
+            undefine_attribute_methods
+            define_attribute_methods attributes.keys
+
+            generated_methods.module_eval do
+              remove_method field
+              remove_method :"#{field}="
+              remove_method :"#{field}?"
+              remove_method :"#{field}_before_type_cast"
+            end
+          end
+
+          private
+
+          def generated_methods
+            @generated_methods ||= begin
+              Module.new.tap do |mod|
+                include(mod)
+              end
+            end
+          end
+
+          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")
+            end
+          end
+        end
+
+        def attribute_names
+          @attributes.keys
+        end
+
+        def has_attribute?(attr_name)
+          @attributes.key?(attr_name.to_sym)
+        end
+
+        def evaluate_default_value(val)
+          if val.respond_to?(:call)
+            val.call
+          elsif val.duplicable?
+            val.dup
+          else
+            val
+          end
+        end
+
+        attr_accessor :attributes
+
+        def write_attribute(name, value)
+          attributes[name.to_sym] = value
+        end
+
+        alias []= write_attribute
+
+        def read_attribute(name)
+          attributes[name.to_sym]
+        end
+        alias [] read_attribute
+
+        def set_created_at
+          self.created_at ||= DateTime.now.in_time_zone(Time.zone).to_s if timestamps_enabled?
+        end
+
+        def timestamps_enabled?
+          self.class.options[:timestamps] || (self.class.options[:timestamps].nil? && Config.timestamps)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Aliyun
+  module Log
+    module Record
+      module Persistence
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def logstore_name
+            @logstore_name ||= options[:name] || base_class.name.split('::').last.downcase.pluralize
+          end
+
+          def logstore_name=(value)
+            if defined?(@logstore_name)
+              return if value == @logstore_name
+            end
+
+            @logstore_name = value
+          end
+
+          def project_name
+            unless @project_name
+              @project_name = options[:project] || Config.project
+              raise ProjectNameError, "project can't be empty" if @project_name.blank?
+            end
+            @project_name
+          end
+
+          def create_logstore(options = {})
+            Log.record_connection.get_logstore(project_name, logstore_name)
+          rescue ServerError => e
+            Log.record_connection.create_logstore(project_name, logstore_name, options)
+          end
+
+          def sync_index
+            has_index? ? update_index : create_index
+          end
+
+          def auto_load_schema
+            return if _schema_load
+
+            create_logstore
+            sync_index
+            self._schema_load = true
+          end
+
+          def has_index?
+            Log.record_connection.get_index(project_name, logstore_name)
+            true
+          rescue ServerError
+            false
+          end
+
+          def create(data, opts = {})
+            auto_load_schema
+            if data.is_a?(Array)
+              logs = []
+              data.each do |log_attr|
+                logs << new(log_attr).save_array
+              end
+              res = Log.record_connection.put_log(project_name, logstore_name, logs, opts)
+              res.code == 200
+            else
+              new(data).save
+            end
+          end
+
+          private
+
+          def evaluate_default_value(val)
+            if val.respond_to?(:call)
+              val.call
+            elsif val.duplicable?
+              val.dup
+            else
+              val
+            end
+          end
+
+          def field_indices
+            if options[:field_index] == true
+              attributes.reject { |_, value| value[:index] == false }
+            else
+              attributes.select { |_, value| value[:index] == true }
+            end
+          end
+
+          def create_index
+            Log.record_connection.create_index(
+              project_name,
+              logstore_name,
+              field_indices
+            )
+          end
+
+          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
+            end
+            return if index_conf['keys'] == raw_conf['keys']
+
+            Log.record_connection.update_index(
+              project_name,
+              logstore_name,
+              index_conf['keys']
+            )
+          end
+        end
+
+        def save
+          self.class.auto_load_schema
+          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.code == 200
+              else
+                false
+              end
+            end
+          end
+        end
+
+        def save_array
+          run_callbacks(:create) do
+            run_callbacks(:save) do
+              validate! && attributes
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Aliyun
+  module Log
+    module Record
+      class Relation
+        def initialize(klass, opts = {})
+          @klass = klass
+          @opts = opts
+          @klass.auto_load_schema
+          @opts[:search] ||= '*'
+        end
+
+        def from(from)
+          ts = from.is_a?(Integer) ? from : from.to_time.to_i
+          @opts[:from] = ts
+          self
+        end
+
+        def to(to)
+          ts = to.is_a?(Integer) ? to : to.to_time.to_i
+          @opts[:to] = ts
+          self
+        end
+
+        def line(val)
+          @opts[:line] = val.to_i
+          self
+        end
+        alias limit line
+
+        def offset(val)
+          @opts[:offset] = val.to_i
+          self
+        end
+
+        def page(val)
+          @opts[:page] = val - 1 if val >= 1
+          self
+        end
+
+        def where(opts)
+          @opts.merge!(opts)
+          self
+        end
+
+        def search(str)
+          @opts[:search] = str
+          self
+        end
+
+        def sql(str)
+          @opts[:sql] = str
+          self
+        end
+
+        def query(opts = {})
+          @opts[:query] = opts
+          self
+        end
+
+        def count
+          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
+        end
+
+        def result
+          query = @opts.dup
+          if query[:page]
+            query[:line] ||= 100
+            query[:offset] = query[:page] * query[:line]
+          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)
+        end
+
+        def load
+          result.map do |json_attr|
+            attrs = {}
+            @klass.attributes.keys.each do |k, _|
+              attrs[k] = json_attr[k.to_s]
+            end
+            @klass.new(attrs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/log/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rest-client'
 require 'base64'
 require 'openssl'
@@ -18,10 +20,10 @@ module Aliyun
         resources ||= {}
         res = '/'
         if resources[:logstore]
-          res << 'logstores'
-          res << "/#{resources[:logstore]}" unless resources[:logstore].empty?
+          res = "#{res}logstores"
+          res = "#{res}/#{resources[:logstore]}" unless resources[:logstore].empty?
         end
-        res << "/#{resources[:action]}" if resources[:action]
+        res = "#{res}/#{resources[:action]}" if resources[:action]
         res
       end
 
@@ -51,28 +53,24 @@ module Aliyun
 
       def do_request(verb, resources, payload)
         resource_path = get_resource_path(resources)
-        headers = {}
-        if verb == 'GET'
-          headers = compact_headers
-          headers['Authorization'] = signature(verb, resource_path, headers, payload)
-        else
-          headers = compact_headers(payload, resources[:is_pb])
-          headers['Authorization'] = signature(verb, resource_path, headers)
-        end
         request_options = {
           method: verb,
           url: get_request_url(resources),
-          headers: headers,
           open_timeout: @config.open_timeout,
           read_timeout: @config.read_timeout
         }
         if verb == 'GET'
-          request_options[:url] = canonicalized_resource(request_options[:url], payload)
+          headers = compact_headers
+          headers['Authorization'] = signature(verb, resource_path, headers, payload)
+          request_options[:headers] = headers
+          request_options[:url] = URI.escape(canonicalized_resource(request_options[:url], payload))
         else
+          headers = compact_headers(payload, resources[:is_pb])
+          headers['Authorization'] = signature(verb, resource_path, headers)
+          request_options[:headers] = headers
           payload = Zlib::Deflate.deflate(payload.encode) if resources[:is_pb]
           request_options[:payload] = payload
         end
-        logger.debug(request_options)
         request = RestClient::Request.new(request_options)
         response = request.execute do |resp|
           if resp.code >= 300
@@ -99,11 +97,12 @@ module Aliyun
           'User-Agent' => "aliyun-log ruby-#{RUBY_VERSION}/#{RUBY_PLATFORM}"
         }
         return headers if body.nil?
+
         if is_pb
           compressed = Zlib::Deflate.deflate(body.encode)
           headers['Content-Length'] = compressed.bytesize.to_s
-          # 日志内容包含的日志必须小于3MB和4096条。
-          raise 'content length is larger than 3MB' if headers['Content-Length'].to_i > 3145728
+          raise 'content length is larger than 3MB' if headers['Content-Length'].to_i > 3_145_728
+
           headers['Content-MD5'] = Digest::MD5.hexdigest(compressed).upcase
           headers['Content-Type'] = 'application/x-protobuf'
           headers['x-log-compresstype'] = 'deflate'
@@ -122,7 +121,6 @@ module Aliyun
           @config.access_key_secret,
           string_to_sign(verb, resource, headers, query).chomp
         )
-        logger.debug "\n#{string_to_sign(verb, resource, headers, query).chomp}"
         base64_sign = Base64.strict_encode64(sha1_digest)
         "LOG #{@config.access_key_id}:#{base64_sign}"
       end
@@ -133,12 +131,12 @@ module Aliyun
           #{headers['Content-MD5']}
           #{headers['Content-Type']}
           #{headers['Date']}
-          #{canonicalized_sls_headers(headers)}
+          #{canonicalized_headers(headers)}
           #{canonicalized_resource(resource, query)}
         DOC
       end
 
-      def canonicalized_sls_headers(headers)
+      def canonicalized_headers(headers)
         h = {}
         headers.each do |k, v|
           h[k.downcase] = v if k =~ /x-log-.*/
@@ -151,11 +149,12 @@ module Aliyun
 
       def canonicalized_resource(resource = '', query = {})
         return resource if query.empty?
+
         url = URI.parse(resource)
-        q_str = query.keys.sort.map do |e|
+        sort_str = query.keys.sort.map do |e|
           "#{e}=#{query[e]}"
         end.join('&')
-        "#{url}?#{q_str}"
+        "#{url}?#{sort_str}"
       end
     end
   end

data/lib/aliyun/log/server_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module Aliyun

data/lib/aliyun/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Aliyun
   module Log
-    VERSION = "0.1.0"
+    VERSION = '0.2.2'
   end
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: aliyun-log
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Yingce Liu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-04 00:00:00.000000000 Z
+date: 2020-06-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: protobuf
   requirement: !ruby/object:Gem::Requirement
@@ -30,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -86,7 +114,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Aliyun Log SDK for Ruby
+description: Aliyun Log SDK for Ruby 阿里云日志服务(SLS) Ruby SDK, 目前仅实现基于Restfull部分接口和简单Model映射
 email:
 - yingce@live.com
 executables: []
@@ -103,6 +131,11 @@ files:
 - lib/aliyun/log/project.rb
 - lib/aliyun/log/protobuf.rb
 - lib/aliyun/log/protocol.rb
+- lib/aliyun/log/record.rb
+- lib/aliyun/log/record/exception.rb
+- lib/aliyun/log/record/field.rb
+- lib/aliyun/log/record/persistence.rb
+- lib/aliyun/log/record/relation.rb
 - lib/aliyun/log/request.rb
 - lib/aliyun/log/server_error.rb
 - lib/aliyun/version.rb