thinkingdata-ruby 1.2.1 → 2.0.0

data/lib/thinkingdata-ruby/{batch_consumer.rb → td_batch_consumer.rb}

@@ -1,118 +1,142 @@
-require 'json'
-require 'net/http'
-
-module TDAnalytics
-  class BatchConsumer
-
-    # buffer count
-    DEFAULT_LENGTH = 20
-    MAX_LENGTH = 2000
-
-    def initialize(server_url, app_id, max_buffer_length = DEFAULT_LENGTH)
-      @server_uri = URI.parse(server_url)
-      @server_uri.path = '/sync_server'
-      @app_id = app_id
-      @compress = true
-      @max_length = [max_buffer_length, MAX_LENGTH].min
-      @buffers = []
-    end
-
-    def _set_compress(compress)
-      @compress = compress
-    end
-
-    def add(message)
-      @buffers << message
-      flush if @buffers.length >= @max_length
-    end
-
-    def close
-      flush
-    end
-
-    def flush
-      begin
-        @buffers.each_slice(@max_length) do |chunk|
-          if @compress
-            wio = StringIO.new("w")
-            gzip_io = Zlib::GzipWriter.new(wio)
-            gzip_io.write(chunk.to_json)
-            gzip_io.close
-            data = wio.string
-          else
-            data = chunk.to_json
-          end
-          compress_type = @compress ? 'gzip' : 'none'
-          headers = {'Content-Type' => 'application/plaintext',
-                     'appid' => @app_id,
-                     'compress' => compress_type,
-                     'TA-Integration-Type'=>'Ruby',
-                     'TA-Integration-Version'=>TDAnalytics::VERSION,
-                     'TA-Integration-Count'=>@buffers.count,
-                     'TA_Integration-Extra'=>'batch'}
-          request = CaseSensitivePost.new(@server_uri.request_uri, headers)
-          request.body = data
-
-          begin
-            response_code, response_body = _request(@server_uri, request)
-          rescue => e
-            raise ConnectionError.new("Could not connect to TA server, with error \"#{e.message}\".")
-          end
-
-          result = {}
-          if response_code.to_i == 200
-            begin
-              result = JSON.parse(response_body.to_s)
-            rescue JSON::JSONError
-              raise ServerError.new("Could not interpret TA server response: '#{response_body}'")
-            end
-          end
-
-          if result['code'] != 0
-            raise ServerError.new("Could not write to TA, server responded with #{response_code} returning: '#{response_body}'")
-          end
-        end
-      rescue
-        raise
-      end
-      @buffers = []
-    end
-
-    private
-    def _request(uri, request)
-      client = Net::HTTP.new(uri.host, uri.port)
-      client.use_ssl = uri.scheme === 'https' ? true : false
-      client.open_timeout = 10
-      client.continue_timeout = 10
-      client.read_timeout = 10
-      client.ssl_timeout = 10
-
-      response = client.request(request)
-      [response.code, response.body]
-    end
-  end
-
-  class CaseSensitivePost < Net::HTTP::Post
-    def initialize_http_header(headers)
-      @header = {}
-      headers.each{|k,v| @header[k.to_s] = [v] }
-    end
-
-    def [](name)
-      @header[name.to_s]
-    end
-
-    def []=(name, val)
-      if val
-        @header[name.to_s] = [val]
-      else
-        @header.delete(name.to_s)
-      end
-    end
-
-    def capitalize(name)
-      name
-    end
-  end
-
-end
+require 'json'
+require 'net/http'
+require 'stringio'
+
+module ThinkingData
+  ##
+  # Upload data by http
+  class TDBatchConsumer
+
+    # buffer count
+    DEFAULT_LENGTH = 20
+    MAX_LENGTH = 2000
+
+    ##
+    # Init batch consumer
+    def initialize(server_url, app_id, max_buffer_length = DEFAULT_LENGTH)
+      @server_uri = URI.parse(server_url)
+      @server_uri.path = '/sync_server'
+      @app_id = app_id
+      @compress = true
+      @max_length = [max_buffer_length, MAX_LENGTH].min
+      @buffers = []
+      TDLog.info("TDBatchConsumer init success. ServerUrl: #{server_url}, appId: #{app_id}")
+    end
+
+    ##
+    # http request compress
+    # @param compress [Boolean] compress or not
+    # @deprecated please use: set_compress
+    def _set_compress(compress)
+      @compress = compress
+    end
+
+    ##
+    # http request compress
+    # @param compress [Boolean] compress or not
+    def set_compress(compress)
+      @compress = compress
+    end
+
+    def add(message)
+      TDLog.info("Enqueue data to buffer. buffer size: #{@buffers.length}, data: #{message}")
+      @buffers << message
+      flush if @buffers.length >= @max_length
+    end
+
+    def close
+      flush
+      TDLog.info("TDBatchConsumer close.")
+    end
+
+    def flush
+      TDLog.info("TDBatchConsumer flush data.")
+      begin
+        @buffers.each_slice(@max_length) do |chunk|
+          if @compress
+            wio = StringIO.new("w")
+            gzip_io = Zlib::GzipWriter.new(wio)
+            gzip_io.write(chunk.to_json)
+            gzip_io.close
+            data = wio.string
+          else
+            data = chunk.to_json
+          end
+          compress_type = @compress ? 'gzip' : 'none'
+          headers = {'Content-Type' => 'application/plaintext',
+                     'appid' => @app_id,
+                     'compress' => compress_type,
+                     'TE-Integration-Type'=>'Ruby',
+                     'TE-Integration-Version'=>ThinkingData::VERSION,
+                     'TE-Integration-Count'=>@buffers.count,
+                     'TA_Integration-Extra'=>'batch'}
+          request = CaseSensitivePost.new(@server_uri.request_uri, headers)
+          request.body = data
+
+          TDLog.info("Send data, request: #{data}")
+          begin
+            response_code, response_body = _request(@server_uri, request)
+            TDLog.info("Send data, response: #{response_body}")
+          rescue => e
+            raise ConnectionError.new("Could not connect to TE server, with error \"#{e.message}\".")
+          end
+
+          result = {}
+          if response_code.to_i == 200
+            begin
+              result = JSON.parse(response_body.to_s)
+            rescue JSON::JSONError
+              raise ServerError.new("Could not interpret TE server response: '#{response_body}'")
+            end
+          end
+
+          if result['code'] != 0
+            raise ServerError.new("Could not write to TE, server responded with #{response_code} returning: '#{response_body}'")
+          end
+        end
+      rescue
+        raise
+      end
+      @buffers = []
+    end
+
+    private
+    def _request(uri, request)
+      client = Net::HTTP.new(uri.host, uri.port)
+      client.use_ssl = uri.scheme === 'https' ? true : false
+      client.open_timeout = 10
+      client.continue_timeout = 10
+      client.read_timeout = 10
+      client.ssl_timeout = 10
+
+      response = client.request(request)
+      [response.code, response.body]
+    end
+  end
+
+  ##
+  # Private class. Send data tools
+  class CaseSensitivePost < Net::HTTP::Post
+    def initialize_http_header(headers)
+      @header = {}
+      headers.each{|k,v| @header[k.to_s] = [v] }
+    end
+
+    def [](name)
+      @header[name.to_s]
+    end
+
+    def []=(name, val)
+      if val
+        @header[name.to_s] = [val]
+      else
+        @header.delete(name.to_s)
+      end
+    end
+
+    def capitalize(name)
+      name
+    end
+  end
+
+end

data/lib/thinkingdata-ruby/{debug_consumer.rb → td_debug_consumer.rb}

@@ -1,67 +1,73 @@
-require 'json'
-require 'net/http'
-
-module TDAnalytics
-  # The data is reported one by one, and when an error occurs, the log will be printed on the console.
-  class DebugConsumer
-
-    def test
-
-    end
-
-    def initialize(server_url, app_id, write_data = true, device_id: nil)
-      @server_uri = URI.parse(server_url)
-      @server_uri.path = '/data_debug'
-      @app_id = app_id
-      @write_data = write_data
-      @device_id = device_id
-    end
-
-    def add(message)
-      puts message.to_json
-      headers =  {
-          'TA-Integration-Type'=>'Ruby',
-          'TA-Integration-Version'=>TDAnalytics::VERSION,
-          'TA-Integration-Count'=>'1',
-          'TA_Integration-Extra'=>'debug'
-      }
-      form_data = {"data" => message.to_json, "appid" => @app_id, "dryRun" => @write_data ? "0" : "1", "source" => "server"}
-      @device_id.is_a?(String) ? form_data["deviceId"] = @device_id : nil
-
-      begin
-        response_code, response_body = request(@server_uri, form_data,headers)
-      rescue => e
-        raise ConnectionError.new("Could not connect to TA server, with error \"#{e.message}\".")
-      end
-
-      result = {}
-      if response_code.to_i == 200
-        begin
-          result = JSON.parse(response_body.to_s)
-        rescue JSON::JSONError
-          raise ServerError.new("Could not interpret TA server response: '#{response_body}'")
-        end
-      end
-
-      if result['errorLevel'] != 0
-        raise ServerError.new("Could not write to TA, server responded with #{response_code} returning: '#{response_body}'")
-      end
-    end
-
-    def request(uri, form_data,headers)
-      request = Net::HTTP::Post.new(uri.request_uri,headers)
-      request.set_form_data(form_data)
-
-      client = Net::HTTP.new(uri.host, uri.port)
-      client.use_ssl = uri.scheme === 'https' ? true : false
-      client.open_timeout = 10
-      client.continue_timeout = 10
-      client.read_timeout = 10
-      client.ssl_timeout = 10
-
-      response = client.request(request)
-      [response.code, response.body]
-    end
-  end
-
-end
+require 'json'
+require 'net/http'
+
+module ThinkingData
+  ##
+  # The data is reported one by one, and when an error occurs, the log will be printed on the console.
+  class TDDebugConsumer
+
+    ##
+    # Init debug consumer
+    #   @param server_url: server url
+    #   @param app_id: app id
+    #   @param write_data: is write data to TE
+    #   @param device_id: device id
+    def initialize(server_url, app_id, write_data = true, device_id: nil)
+      @server_uri = URI.parse(server_url)
+      @server_uri.path = '/data_debug'
+      @app_id = app_id
+      @write_data = write_data
+      @device_id = device_id
+      TDLog.info("TDDebugConsumer init success. ServerUrl: #{server_url}, appId: #{app_id}, deviceId: #{device_id}")
+    end
+
+    def add(message)
+      msg_json_str = message.to_json
+      TDLog.info("Send data, request: #{msg_json_str}")
+      headers =  {
+          'TE-Integration-Type'=>'Ruby',
+          'TE-Integration-Version'=>ThinkingData::VERSION,
+          'TE-Integration-Count'=>'1',
+          'TA_Integration-Extra'=>'debug'
+      }
+      form_data = {"data" => msg_json_str, "appid" => @app_id, "dryRun" => @write_data ? "0" : "1", "source" => "server"}
+      @device_id.is_a?(String) ? form_data["deviceId"] = @device_id : nil
+
+      begin
+        response_code, response_body = request(@server_uri, form_data,headers)
+        TDLog.info("Send data, response: #{response_body}")
+      rescue => e
+        raise ConnectionError.new("Could not connect to TE server, with error \"#{e.message}\".")
+      end
+
+      result = {}
+      if response_code.to_i == 200
+        begin
+          result = JSON.parse(response_body.to_s)
+        rescue JSON::JSONError
+          raise ServerError.new("Could not interpret TE server response: '#{response_body}'")
+        end
+      end
+
+      if result['errorLevel'] != 0
+        raise ServerError.new("Could not write to TE, server responded with #{response_code} returning: '#{response_body}'")
+      end
+    end
+
+    def request(uri, form_data,headers)
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+      request.set_form_data(form_data)
+
+      client = Net::HTTP.new(uri.host, uri.port)
+      client.use_ssl = uri.scheme === 'https' ? true : false
+      client.open_timeout = 10
+      client.continue_timeout = 10
+      client.read_timeout = 10
+      client.ssl_timeout = 10
+
+      response = client.request(request)
+      [response.code, response.body]
+    end
+  end
+
+end

data/lib/thinkingdata-ruby/{errors.rb → td_errors.rb}

@@ -1,30 +1,38 @@
-module TDAnalytics
-
-  TDAnalyticsError = Class.new(StandardError)
-
-  IllegalParameterError = Class.new(TDAnalyticsError)
-  
-  ConnectionError = Class.new(TDAnalyticsError)
-  
-  ServerError = Class.new(TDAnalyticsError)
-
-
-  # use example:
-  #
-  #    class MyErrorHandler < TDAnalytics::ErrorHandler
-  #      def handle(error)
-  #          puts error
-  #          raise error
-  #      end
-  #    end
-  #
-  #    my_error_handler = MyErrorHandler.new
-  #    tracker = TDAnalytics::Tracker.new(consumer, my_error_handler)
-  class ErrorHandler
-
-    # Override #handle to customize error handling
-    def handle(error)
-      false
-    end
-  end
+module ThinkingData
+  ##
+  # SDK error
+  TDAnalyticsError = Class.new(StandardError)
+
+  ##
+  # SDK error: illegal parameter
+  IllegalParameterError = Class.new(TDAnalyticsError)
+
+  ##
+  # SDK error: connection error
+  ConnectionError = Class.new(TDAnalyticsError)
+
+  ##
+  # SDK error: server error
+  ServerError = Class.new(TDAnalyticsError)
+
+  ##
+  # Error handler
+  #
+  # e.g.
+  #    class MyErrorHandler < ThinkingData::ErrorHandler
+  #      def handle(error)
+  #          puts error
+  #          raise error
+  #      end
+  #    end
+  #
+  #    my_error_handler = MyErrorHandler.new
+  #    tracker = ThinkingData::TDAnalytics.new(consumer, my_error_handler)
+  class TDErrorHandler
+    ##
+    # Override #handle to customize error handling
+    def handle(error)
+      false
+    end
+  end
 end

data/lib/thinkingdata-ruby/{logger_consumer.rb → td_logger_consumer.rb}

@@ -1,66 +1,77 @@
-require 'logger'
-require 'thinkingdata-ruby/errors'
-
-module TDAnalytics
-
-  # dismantle the header and save it under another name
-  class HeadlessLogger < Logger
-    def initialize(logdev, shift_age = 0, shift_size = 1048576)
-      super(nil )
-      if logdev
-        @logdev = HeadlessLogger::LogDevice.new(logdev, shift_age: shift_age, shift_size: shift_size)
-      end
-    end
-
-    class LogDevice < ::Logger::LogDevice
-      def add_log_header(file); end
-    end
-  end
-
-  # write data to file, it works with LogBus
-  class LoggerConsumer
-
-    def initialize(log_path='.', mode='daily', prefix:'te.log')
-      case mode
-      when 'hourly'
-        @suffix_mode = '%Y-%m-%d-%H'
-      when 'daily'
-        @suffix_mode = '%Y-%m-%d'
-      else
-        raise IllegalParameterError.new("#{mode} is unsupported for LoggerConsumer. Replaced it by daily or hourly")
-      end
-
-      raise IllegalParameterError.new("prefix couldn't be empty") if prefix.nil? || prefix.length == 0
-
-      @current_suffix = Time.now.strftime(@suffix_mode)
-      @log_path = log_path
-      @full_prefix = "#{log_path}/#{prefix}"
-      _reset
-    end
-
-    def add(msg)
-      unless Time.now.strftime(@suffix_mode) == @current_suffix
-        @logger.close
-        @current_suffix = Time.now.strftime(@suffix_mode)
-        _reset
-      end
-      @logger.info(msg.to_json)
-    end
-  
-    def close
-      @logger.close
-    end
-
-    private
-
-    def _reset
-      Dir::mkdir(@log_path) unless Dir::exist?(@log_path)
-      @logger = HeadlessLogger.new("#{@full_prefix}.#{@current_suffix}")
-      @logger.level = HeadlessLogger::INFO
-      @logger.formatter = proc do |severity, datetime, progname, msg|
-        "#{msg}\n"
-      end
-    end
-
-  end
+require 'logger'
+require 'thinkingdata-ruby/td_errors'
+
+module ThinkingData
+
+  ##
+  # Dismantle the header and save it under another name
+  class HeadlessLogger < Logger
+    def initialize(logdev, shift_age = 0, shift_size = 1048576)
+      super(nil)
+      if logdev
+        @logdev = HeadlessLogger::LogDevice.new(logdev, shift_age: shift_age, shift_size: shift_size)
+      end
+    end
+
+    class LogDevice < ::Logger::LogDevice
+      def add_log_header(file); end
+    end
+  end
+
+  ##
+  # Write data to file, it works with LogBus
+  class TDLoggerConsumer
+
+    ##
+    # Init logger consumer
+    #   @param log_path: log file's path
+    #   @param mode: file rotate mode
+    #   @param prefix: file prefix
+    def initialize(log_path='.', mode='daily', prefix:'te.log')
+      case mode
+      when 'hourly'
+        @suffix_mode = '%Y-%m-%d-%H'
+      when 'daily'
+        @suffix_mode = '%Y-%m-%d'
+      else
+        raise IllegalParameterError.new("#{mode} is unsupported for LoggerConsumer. Replaced it by daily or hourly")
+      end
+
+      raise IllegalParameterError.new("prefix couldn't be empty") if prefix.nil? || prefix.length == 0
+
+      @current_suffix = Time.now.strftime(@suffix_mode)
+      @log_path = log_path
+      @full_prefix = "#{log_path}/#{prefix}"
+      TDLog.info("TDLoggerConsumer init success. LogPath: #{log_path}")
+      _reset
+    end
+
+    def add(msg)
+      unless Time.now.strftime(@suffix_mode) == @current_suffix
+        @logger.close
+        @current_suffix = Time.now.strftime(@suffix_mode)
+        _reset
+      end
+      msg_json_str = msg.to_json
+      TDLog.info("Write data to file: #{msg_json_str}")
+      @logger.info(msg_json_str)
+    end
+  
+    def close
+      @logger.close
+      TDLog.info("TDLoggerConsumer close.")
+    end
+
+    private
+
+    def _reset
+      Dir::mkdir(@log_path) unless Dir::exist?(@log_path)
+      @logger = HeadlessLogger.new("#{@full_prefix}.#{@current_suffix}")
+      @logger.level = HeadlessLogger::INFO
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+    end
+
+  end
 end

data/lib/thinkingdata-ruby/td_version.rb

@@ -0,0 +1,3 @@
+module ThinkingData
+  VERSION = '2.0.0'
+end

data/lib/thinkingdata-ruby.rb

@@ -1,5 +1,5 @@
-require 'thinkingdata-ruby/logger_consumer'
-require 'thinkingdata-ruby/debug_consumer'
-require 'thinkingdata-ruby/batch_consumer'
-require 'thinkingdata-ruby/tracker'
-require 'thinkingdata-ruby/errors'
+require 'thinkingdata-ruby/td_logger_consumer'
+require 'thinkingdata-ruby/td_debug_consumer'
+require 'thinkingdata-ruby/td_batch_consumer'
+require 'thinkingdata-ruby/td_analytics'
+require 'thinkingdata-ruby/td_errors'