aliyun-log 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0af7f849c9e5e9e6d59647f4b184c994977407f5b970f5d867505062401621c7
+  data.tar.gz: bfd3fafdac4839ac11d428638d44d15a4126d283195ddd6e5b033238f3e7b034
+SHA512:
+  metadata.gz: 033ae7fd59ab6e49b40c071942f289623226ca9a506f88cec0eafdce2edabcc56c5b2daecd7f7c8a6e27df39c11ebf62deab06c3d11b175c4b1f7eeef5284f5f
+  data.tar.gz: f31dc59e00955ecc7b0f6682356005b7ea2b872527818ea352418a99ddd81a8d3b0fd4d66f7fbda9c92073d9e8d51eca38b7af11364f2bf2d359ad565ac0299b

data/lib/aliyun/log.rb

@@ -0,0 +1,18 @@
+# 
+require_relative 'log/common'
+require_relative 'log/client'
+require_relative 'log/config'
+require_relative 'log/logstore'
+require_relative 'log/project'
+require_relative 'log/protobuf'
+require_relative 'log/protocol'
+require_relative 'log/request'
+require_relative 'log/server_error'
+
+module Aliyun
+  module Log
+    def self.configure
+      block_given? ? yield(Config) : Config
+    end
+  end
+end

data/lib/aliyun/log/client.rb

@@ -0,0 +1,30 @@
+module Aliyun
+  module Log
+    class Client
+      def initialize(config = {})
+        @config = Config.new(config)
+        @protocol = Protocol.new(@config)
+      end
+
+      def list_projects(size = nil, offset = nil)
+        @protocol.list_projects(size, offset)
+      end
+
+      def get_project(name)
+        @protocol.get_project(name)
+      end
+
+      def create_project(name, desc)
+        @protocol.create_project(name, desc)
+      end
+
+      def update_project(name, desc)
+        @protocol.update_project(name, desc)
+      end
+
+      def delete_project(name)
+        @protocol.delete_project(name)
+      end
+    end
+  end
+end

data/lib/aliyun/log/common.rb

@@ -0,0 +1,3 @@
+# 
+require_relative 'common/attr_struct'
+require_relative 'common/logging'

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

@@ -0,0 +1,32 @@
+module Aliyun
+  module Log
+    module Common
+      class AttrStruct
+        module AttrHelper
+          def attrs(*name)
+            define_method(:attrs) { name }
+            attr_reader(*name)
+          end
+        end
+
+        extend AttrHelper
+
+        def initialize(opts = {})
+          extra_keys = opts.keys - attrs
+          raise "Unexpected extra keys: #{extra_keys.join(', ')}" unless extra_keys.empty?
+
+          attrs.each do |attr|
+            instance_variable_set("@#{attr}", opts[attr])
+          end
+        end
+
+        def to_s
+          attrs.map do |attr|
+            v = instance_variable_get("@#{attr}")
+            "#{attr}: #{v}"
+          end.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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
+
+        def logger
+          Logging.logger
+        end
+
+        # level = Logger::DEBUG | Logger::INFO | Logger::ERROR | Logger::FATAL
+        def self.log_level=(level)
+          Logging.logger.level = level
+        end
+
+        def self.logger
+          unless @logger
+            @logger = Logger.new(
+              @log_file ||= DEFAULT_LOG_FILE, MAX_NUM_LOG, ROTATE_SIZE
+            )
+            @logger.level = Logger::DEBUG
+          end
+          @logger
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/log/config.rb

@@ -0,0 +1,43 @@
+module Aliyun
+  module Log
+    class Config < Common::AttrStruct
+      @endpoint = 'https://cn-beijing.log.aliyuncs.com'
+      @open_timeout = 10
+      @read_timeout = 120
+      class << self
+        attr_accessor :endpoint, :access_key_id, :access_key_secret,
+                      :open_timeout, :read_timeout
+
+        def configure
+          yield self
+        end
+      end
+
+      attrs :endpoint, :access_key_id, :access_key_secret,
+            :open_timeout, :read_timeout
+
+      def initialize(opts = {})
+        super(opts)
+        @open_timeout ||= self.class.open_timeout
+        @read_timeout ||= self.class.read_timeout
+        @access_key_id ||= self.class.access_key_id
+        @access_key_secret ||= self.class.access_key_secret
+        @endpoint ||= self.class.endpoint
+        normalize_endpoint
+      end
+
+      private
+
+        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
+
+          @endpoint = uri.to_s
+        end
+    end
+  end
+end

data/lib/aliyun/log/logstore.rb

@@ -0,0 +1,74 @@
+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
+
+      def initialize(opts, protocol)
+        super(opts)
+        @protocol = protocol
+      end
+
+      def self.from_json(attrs, protocol)
+        new({
+              name: attrs['logstoreName'],
+              project_name: attrs['projectName'],
+              ttl: attrs['ttl'],
+              shared_count: attrs['shardCount'],
+              enable_tracking: attrs['enable_tracking'],
+              auto_split: attrs['autoSplit'],
+              max_split_shard: attrs['maxSplitShard'],
+              create_time: attrs['createTime'],
+              last_modify_time: attrs['lastModifyTime']
+            }, protocol)
+      end
+
+      def put_logs(content)
+        @protocol.put_logs(project_name, name, content)
+      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)
+      end
+
+      def get_logs(opts = {})
+        @protocol.get_logs(project_name, name, opts)
+      end
+
+      def get_histograms(opts = {})
+        @protocol.get_histograms(project_name, name, opts)
+      end
+
+      def list_topics(opts = {})
+        @protocol.list_topics(project_name, name, opts)
+      end
+
+      def get_index
+        @protocol.get_index(project_name, name)
+      end
+
+      def create_index_line(token = nil)
+        @protocol.create_index_line(project_name, name, token)
+      end
+
+      def create_index(fields)
+        @protocol.create_index(project_name, name, fields)
+      end
+
+      def update_index(fields)
+        @protocol.update_index(project_name, name, fields)
+      end
+
+      def delete_index
+        @protocol.delete_index(project_name, name)
+      end
+    end
+  end
+end

data/lib/aliyun/log/project.rb

@@ -0,0 +1,45 @@
+module Aliyun
+  module Log
+    class Project < Common::AttrStruct
+      attrs :create_time, :description, :last_modify_time,
+            :owner, :name, :region, :status
+
+      def initialize(opts, protocol)
+        super(opts)
+        @protocol = protocol
+      end
+
+      def self.from_json(attrs, protocol)
+        new({
+              create_time: attrs['createTime'],
+              description: attrs['description'],
+              last_modify_time: attrs['lastModifyTime'],
+              owner: attrs['owner'],
+              name: attrs['projectName'],
+              region: attrs['region'],
+              status: attrs['status']
+            }, protocol)
+      end
+
+      def list_logstores(size = nil, offset = nil)
+        @protocol.list_logstores(name, size, offset)
+      end
+
+      def get_logstore(logstore_name)
+        @protocol.get_logstore(name, logstore_name)
+      end
+
+      def create_logstore(logstore_name, opt = {})
+        @protocol.create_logstore(name, logstore_name, opt)
+      end
+
+      def update_logstore(logstore_name)
+        @protocol.update_logstore(name, logstore_name)
+      end
+
+      def delete_logstore(logstore_name)
+        @protocol.delete_logstore(name, logstore_name)
+      end
+    end
+  end
+end

data/lib/aliyun/log/protobuf.rb

@@ -0,0 +1,25 @@
+require 'protobuf'
+
+module Aliyun
+  module Log
+    module Protobuf
+      class Log < ::Protobuf::Message
+        required :uint32, :time, 1
+
+        class Content < ::Protobuf::Message
+          required :string, :key, 1
+          required :string, :value, 2
+        end
+
+        repeated Content, :contents, 2
+      end
+
+      class LogGroup < ::Protobuf::Message
+        repeated Log, :logs, 1
+        optional :string, :reserved, 2
+        optional :string, :topic, 3
+        optional :string, :source, 4
+      end
+    end
+  end
+end

data/lib/aliyun/log/protocol.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Aliyun
+  module Log
+    class Protocol
+      def initialize(config)
+        @http = Request.new(config)
+      end
+
+      def list_projects(size = nil, offset = nil)
+        query = {
+          offset: offset,
+          size: size
+        }.compact
+        data = @http.get(nil, query)
+        data = JSON.parse(data)
+        data['projects'] = data['projects'].map do |attrs|
+          Project.from_json(attrs, self)
+        end
+        data
+      end
+
+      def get_project(project_name)
+        query = { projectName: project_name }
+        attrs = @http.get({ project: project_name }, query)
+        attrs = JSON.parse(attrs)
+        Project.from_json(attrs, self)
+      end
+
+      def create_project(project_name, desc)
+        body = {
+          projectName: project_name,
+          description: desc
+        }
+        @http.post({ project: project_name }, body.to_json)
+      end
+
+      def update_project(project_name, desc)
+        body = {
+          projectName: project_name,
+          description: desc
+        }
+        @http.put({ project: project_name }, body.to_json)
+      end
+
+      def delete_project(project_name)
+        body = { projectName: project_name }
+        @http.delete({ project: project_name }, body.to_json)
+      end
+
+      def list_logstores(project_name, size = nil, offset = nil)
+        query = {
+          offset: offset,
+          size: size
+        }.compact
+        data = @http.get({ project: project_name, logstore: '' }, query)
+        JSON.parse(data)
+      end
+
+      def create_logstore(project_name, logstore_name, opt = {})
+        body = {
+          logstore_name: logstore_name,
+          ttl: opt[:ttl] || 365,
+          shardCount: opt[:shard_count] || 2,
+          autoSplit: opt[:auto_split].nil? ? false : opt[:auto_split],
+          maxSplitShard: opt[:max_split_shard],
+          enable_tracking: opt[:enable_tracking].nil? ? false : opt[:enable_tracking]
+        }.compact
+        @http.post({ project: project_name, logstore: '' }, body.to_json)
+      end
+
+      def update_logstore(project_name, logstore_name, opt = {})
+        body = {
+          logstore_name: logstore_name,
+          ttl: opt[:ttl] || 365,
+          shardCount: opt[:shard_count] || 2,
+          autoSplit: opt[:auto_split].nil? ? false : opt[:auto_split],
+          maxSplitShard: opt[:max_split_shard],
+          enable_tracking: opt[:enable_tracking].nil? ? false : opt[:enable_tracking]
+        }.compact
+        @http.put({ project: project_name, logstore: logstore_name }, body.to_json)
+      end
+
+      def delete_logstore(project_name, logstore_name)
+        body = { logstore_name: logstore_name }
+        @http.delete({ project: project_name, logstore: logstore_name }, body.to_json)
+      end
+
+      def get_logstore(project_name, logstore_name)
+        query = { logstore_name: logstore_name }
+        attrs = @http.get({ project: project_name, logstore: logstore_name }, query)
+        attrs = JSON.parse(attrs)
+        attrs['projectName'] = project_name
+        Logstore.from_json(attrs, self)
+      end
+
+      def put_logs(project_name, logstore_name, content)
+        @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])
+        @http.post({ project: project_name, logstore: logstore_name, is_pb: true }, lg_pb)
+      end
+
+      DEFAULT_LOG_TIME_SHIFT = 900
+
+      def get_logs(project_name, logstore_name, opt = {})
+        from = opt[:from] || (Time.now - DEFAULT_LOG_TIME_SHIFT).to_i
+        to = opt[:to] || Time.now.to_i
+        query = {
+          type: 'log',
+          from: from,
+          to: to,
+          line: opt[:line],
+          offset: opt[:offset],
+          reverse: opt[:reverse],
+          query: opt[:query],
+          topic: opt[:topic]
+        }.compact
+        @http.get({ project: project_name, logstore: logstore_name }, query)
+      end
+
+      def get_histograms(project_name, logstore_name, opt = {})
+        from = opt[:from] || (Time.now - DEFAULT_LOG_TIME_SHIFT).to_i
+        to = opt[:to] || Time.now.to_i
+        query = {
+          type: 'histogram',
+          from: from,
+          to: to,
+          query: opt[:query],
+          topic: opt[:topic]
+        }.compact
+        @http.get({ project: project_name, logstore: logstore_name }, query)
+      end
+
+      def list_topics(project_name, logstore_name, opt = {})
+        query = {
+          type: 'topic',
+          line: opt[:line] || 100
+        }
+        @http.get({ project: project_name, logstore: logstore_name }, query)
+      end
+
+      def get_index(project_name, logstore_name)
+        query = { logstore_name: logstore_name }
+        @http.get({ project: project_name, logstore: logstore_name, action: 'index' }, query)
+      end
+
+      INDEX_DEFAULT_TOKEN = ", '\";=()[]{}?@&<>/:\n\t\r".split('')
+
+      def create_index_line(project_name, logstore_name, token = nil)
+        body = {
+          line: {
+            token: token || INDEX_DEFAULT_TOKEN
+          }
+        }
+        @http.post({ project: project_name, logstore: logstore_name, action: 'index' }, body.to_json)
+      end
+
+      def create_index(project_name, logstore_name, fields)
+        body = {
+          line: {
+            token: INDEX_DEFAULT_TOKEN
+          },
+          keys: {}
+        }
+        fields.each do |k, v|
+          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
+
+      def update_index(project_name, logstore_name, fields)
+        body = {
+          line: {
+            token: INDEX_DEFAULT_TOKEN
+          },
+          keys: {}
+        }
+        fields.each do |k, v|
+          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
+
+      def delete_index(project_name, logstore_name)
+        body = { logstore_name: logstore_name }
+        @http.delete({ project: project_name, logstore: logstore_name, action: 'index' }, body.to_json)
+      end
+    end
+  end
+end

data/lib/aliyun/log/request.rb

@@ -0,0 +1,162 @@
+require 'rest-client'
+require 'base64'
+require 'openssl'
+require 'digest'
+require 'date'
+require 'zlib'
+
+module Aliyun
+  module Log
+    class Request
+      include Common::Logging
+
+      def initialize(config)
+        @config = config
+      end
+
+      def get_resource_path(resources = {})
+        resources ||= {}
+        res = '/'
+        if resources[:logstore]
+          res << 'logstores'
+          res << "/#{resources[:logstore]}" unless resources[:logstore].empty?
+        end
+        res << "/#{resources[:action]}" if resources[:action]
+        res
+      end
+
+      def get_request_url(resources = {})
+        resources ||= {}
+        url = URI.parse(@config.endpoint)
+        url.host = "#{resources[:project]}." + url.host if resources[:project]
+        url.path = get_resource_path(resources)
+        url.to_s
+      end
+
+      def get(resources, payload = {})
+        do_request('GET', resources, payload)
+      end
+
+      def post(resources, payload)
+        do_request('POST', resources, payload)
+      end
+
+      def put(resources, payload)
+        do_request('PUT', resources, payload)
+      end
+
+      def delete(resources, payload)
+        do_request('DELETE', resources, payload)
+      end
+
+      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)
+        else
+          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
+            e = ServerError.new(resp)
+            logger.error(e.to_s)
+            raise e
+          else
+            resp.return!
+          end
+        end
+
+        logger.debug("Received HTTP response, code: #{response.code}, headers: " \
+                      "#{response.headers}, body: #{response.body}")
+
+        response
+      end
+
+      def compact_headers(body = nil, is_pb = false)
+        headers = {
+          'x-log-apiversion' => '0.6.0',
+          'x-log-signaturemethod' => 'hmac-sha1',
+          'x-log-bodyrawsize' => '0',
+          'Date' => DateTime.now.httpdate,
+          '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
+          headers['Content-MD5'] = Digest::MD5.hexdigest(compressed).upcase
+          headers['Content-Type'] = 'application/x-protobuf'
+          headers['x-log-compresstype'] = 'deflate'
+          headers['x-log-bodyrawsize'] = body.encode.bytesize.to_s
+        else
+          headers['Content-Type'] = 'application/json'
+          headers['Content-MD5'] = Digest::MD5.hexdigest(body.encode).upcase
+          headers['x-log-bodyrawsize'] = body.bytesize.to_s
+        end
+        headers
+      end
+
+      def signature(verb, resource, headers, query = {})
+        sha1_digest = OpenSSL::HMAC.digest(
+          OpenSSL::Digest.new('sha1'),
+          @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
+
+      def string_to_sign(verb, resource, headers, query = {})
+        <<~DOC
+          #{verb}
+          #{headers['Content-MD5']}
+          #{headers['Content-Type']}
+          #{headers['Date']}
+          #{canonicalized_sls_headers(headers)}
+          #{canonicalized_resource(resource, query)}
+        DOC
+      end
+
+      def canonicalized_sls_headers(headers)
+        h = {}
+        headers.each do |k, v|
+          h[k.downcase] = v if k =~ /x-log-.*/
+        end
+        h.keys.sort.map do |e|
+          h[e]
+          "#{e}:#{h[e].gsub(/^\s+/, '')}"
+        end.join("\n")
+      end
+
+      def canonicalized_resource(resource = '', query = {})
+        return resource if query.empty?
+        url = URI.parse(resource)
+        q_str = query.keys.sort.map do |e|
+          "#{e}=#{query[e]}"
+        end.join('&')
+        "#{url}?#{q_str}"
+      end
+    end
+  end
+end

data/lib/aliyun/log/server_error.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+module Aliyun
+  module Log
+    class ServerError < StandardError
+      attr_reader :http_code, :error_code, :raw_message, :request_id
+
+      def initialize(response)
+        @http_code = response.code
+        body = JSON.parse(response.body)
+        @error_code = body['errorCode']
+        @raw_message = body['errorMessage']
+        if @error_code == 'IndexInfoInvalid'
+          human_info = ' please see the rules: ' \
+                       'https://help.aliyun.com/document_detail/74953.html'
+          @raw_message += human_info
+        end
+        @request_id = response.headers['x-log-requestid']
+      end
+
+      def message
+        @raw_message || "UnknownError[#{http_code}]."
+      end
+
+      def to_s
+        msg = @raw_message || "UnknownError[#{http_code}]."
+        "error_code: #{@error_code} message: #{msg} RequestId: #{request_id}"
+      end
+    end
+  end
+end

data/lib/aliyun/version.rb

@@ -0,0 +1,5 @@
+module Aliyun
+  module Log
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: aliyun-log
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yingce Liu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Aliyun Log SDK for Ruby
+email:
+- yingce@live.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aliyun/log.rb
+- lib/aliyun/log/client.rb
+- lib/aliyun/log/common.rb
+- lib/aliyun/log/common/attr_struct.rb
+- lib/aliyun/log/common/logging.rb
+- lib/aliyun/log/config.rb
+- lib/aliyun/log/logstore.rb
+- lib/aliyun/log/project.rb
+- lib/aliyun/log/protobuf.rb
+- lib/aliyun/log/protocol.rb
+- lib/aliyun/log/request.rb
+- lib/aliyun/log/server_error.rb
+- lib/aliyun/version.rb
+homepage: https://github.com/yingce/aliyun-log
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/yingce/aliyun-log
+  source_code_uri: https://github.com/yingce/aliyun-log
+  changelog_uri: https://github.com/yingce/aliyun-log/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Aliyun Log SDK for Ruby
+test_files: []