thinkingdata-ruby 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: af3bee9acd623d7588b142a62e6ecef998c359c5
-  data.tar.gz: d9f7170bfc7dc600a58fcafbbfba45f92049f6d0
+SHA256:
+  metadata.gz: cdd6d7eb248bfbddc35fdc947a9323ff6a1a16d10c2e396b5cd3f80dd272f866
+  data.tar.gz: e6ee651f3d35226a5f640f0c57868964abe0eba5841335249b262a81b264a018
 SHA512:
-  metadata.gz: 6adee954d6aee35f30ed2a97074ce00500a71b4c02f3b4c1dded0ca44bcfc0e1636a0a564b49b4640114eae5d5a34c978630a8247d59bc6d0547f47deacd2ba6
-  data.tar.gz: d9052f017aae1f57252b7a15abd921f4e23d026c6010bba6d868b39f638a63f782a6a47c1f2faaa46352da11372aae62769601c65e53cde3895ec8d12cbd3be6
+  metadata.gz: 442a30338ce592df0f6c9e3dd505255390e8797d405326009064531f45637bd2c86f1bbca10efd14a8e6dd8b12ebbfe183be0795c8e029fcec19362627024033
+  data.tar.gz: 605e8773859e0147486ed023c7ab187cd308aaf4e810cc1f633d9e72810cbadfd01fe19b45bebd1042e8741b1ac0e791d8662c36c5097e6d94694d5b051d0a0d

data/.gitignore

@@ -0,0 +1,59 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*
+
+.idea/*
+Gemfile.lock

data/CHANGELOG.md

@@ -1,10 +1,16 @@
-**v1.1.0** (2020/02/11)
-- 数据类型支持array类型
-- 新增 user_append 接口，支持用户的数组类型的属性追加
-- BatchConsumer 性能优化：支持选择是否压缩；移除 Base64 编码
-- DebugConsumer 优化: 在服务端对数据进行更完备准确地校验
-
-**v1.0.0** (2019-11-20)
-- 支持三种模式的上报: DebugConsumer, BatchConsumer, LoggerConsumer.
-- 支持事件上报和用户属性上报.
-- 支持公共事件属性.
+### v1.2.1
+**Date:** 2023/03/20
+
+**Notes:**
+
+* Compatible ruby 3
+* Supports a different '#app_id' for each event
+
+
+### v1.2.0
+**Date:** 2020/08/28
+
+**Notes:**
+
+* Added track_update interface to support updatable events
+* Added track_overwrite interface to support rewritable events

data/README.md

@@ -1,202 +1,10 @@
-# ThinkingData Analytics API for Ruby
+# ThinkingData SDK for Ruby
+![output](https://user-images.githubusercontent.com/53337625/205621683-ed9b97ef-6a52-4903-a2c0-a955dddebb7d.png)
 
-thinkingdata-ruby 是数数科技提供给客户，方便客户导入用户数据的 Ruby 接口实现, 支持 Ruby 2.0 以上版本。如需了解详细信息，请参考 [数数科技官方网站](https://www.thinkingdata.cn).
+This is the [ThinkingData](https://www.thinkingdata.cn)™ SDK for Ruby. Documentation is available on our help center in the following languages:
 
-### 一、集成 SDK
+- [English](https://docs.thinkingdata.cn/ta-manual/latest/en/installation/installation_menu/server_sdk/ruby_sdk_installation/ruby_sdk_installation.html)
+- [中文](https://docs.thinkingdata.cn/ta-manual/latest/installation/installation_menu/server_sdk/ruby_sdk_installation/ruby_sdk_installation.html)
+- [日本語](https://docs.thinkingdata.io/ta-manual/v4.0/ja/installation/installation_menu/server_sdk/ruby_sdk_installation/ruby_sdk_installation.html)
 
-#### 1. 安装 SDK
-
-```sh
-# 获取 SDK
-gem install thinkingdata-ruby
-```
-#### 2. 创建 SDK 实例
-首先在代码文件开头引入 `thinkingdata-ruby`:
-```ruby
-require 'thinkingdata-ruby'
-```
-
-使用 SDK 上传数据，需要首先创建 `TDAnalytics::Tracker` 对象. `TDAnalytics::Tracker` 是数据上报的核心类，使用此类上报事件数据和更新用户属性. 创建 `Tracker` 对象需要传入 consumer 对象，consumer 决定了如何处理格式化的数据（存储在本地日志文件还是上传到服务端).
-  
-```ruby
-ta = TDAnalytics::Tracker.new(consumer)
-ta.track('your_event', distinct_id: 'distinct_id_of_user')
-```
-TDAnalytics 提供了三种 consumer 实现:
-
-**(1) LoggerConsumer**: 将数据实时写入本地文件，文件以 天/小时 切分，并需要与 LogBus 搭配使用进行数据上传.
-```ruby
-# 默认写入当前目录的文件，按日期命名(daily)，例如: tda.log.2019-11-15
-consumer = TDAnalytics::LoggerConsumer.new
-
-# 也可以修改配置，如下配置会创建 LoggerConsumer，并将数据写入: /path/to/log/demolog.2019-11-15-18 (18 为小时)
-consumer = TDAnalytics::LoggerConsumer.new('/path/to/log', 'hourly', prefix: 'demolog')
-```
-
-**(2) DebugConsumer**: 逐条实时向 TA 服务器传输数据，当数据格式错误时会返回详细的错误信息。建议先使用 DebugConsumer 校验数据格式。初始化传入项目 APP ID 和接收端地址.
-```ruby
-# 创建 DebugConsumer
-consumer = TDAnalytics::DebugConsumer.new(SERVER_URL, YOUR_APPID)
-```
-
-**(3) BatchConsumer**: 批量实时地向 TA 服务器传输数据，不需要搭配传输工具。在网络条件不好的情况下有可能会导致数据丢失，因此不建议在生产环境中大量使用. 初始化传入项目 APP ID 和接收端地址.
-
-BatchConsumer 会先将数据存放在缓冲区中，当数据条数超过设定的缓冲区最大值(max_buffer_length, 默认为20)，触发上报. 您也可以在初始化 SDK 时传入整数类型的参数配置缓冲区大小:
-```ruby
- # BatchConsumer，数据将先存入缓冲区，达到指定条数时上报，默认为 20 条
- consumer = TDAnalytics::BatchConsumer.new(SERVER_URL, YOUR_APPID)
-
- # 创建指定缓冲区大小为 3 条的 BatchConsumer
- consumer = TDAnalytics::BatchConsumer.new(SERVER_URL, YOUR_APPID, 3)
-```
-  
-您也可以传入自己实现的 Consumer，只需实现以下接口:
-- add(message): (必须) 接受 Hash 类型的数据对象
-- flush: (可选) 将缓冲区的数据发送到指定地址
-- close: (可选) 程序退出时用户可以主动调用此接口以保证安全退出
-
-#### 3. 上报数据
-SDK 初始化完成后，后续即可使用 ta 的接口来上报数据.
-
-### 使用示例
-
-#### a. 发送事件
-您可以调用 track 来上传事件，建议您根据预先梳理的文档来设置事件的属性以及发送信息的条件。上传事件示例如下：
-```ruby
-# 定义事件数据
-event = {
-  # 事件名称 （必填)
-  event_name: 'test_event',
-  # 账号 ID （可选)
-  account_id: 'ruby_test_aid',
-  # 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
-  distinct_id: 'ruby_distinct_id',
-  # 事件时间 (可选) 如果不填，将以调用接口时的时间作为事件时间
-  time: Time.now,
-  # 事件 IP (可选) 当传入 IP 地址时，后台可以解析所在地
-  ip: '202.38.64.1',
-  # 事件属性 (可选)
-  properties: {
-    prop_date: Time.now,
-    prop_double: 134.1,
-    prop_string: 'hello world',
-    prop_bool: true,
-  },
-  # 跳过本地格式校验 (可选)
-  # skip_local_check: true,
-}
-
-# 上传事件
-ta.track(event)
-```
-
-参数说明：
-* 事件的名称只能以字母开头，可包含数字，字母和下划线“_”，长度最大为 50 个字符，对字母大小写不敏感
-* 事件的属性是 Hash 类型，其中每个元素代表一个属性
-* 事件属性的 Key 值为属性的名称，为 string 类型，规定只能以字母开头，包含数字，字母和下划线“_”，长度最大为 50 个字符，对字母大小写不敏感
-* 事件属性的 Value 值为该属性的值，支持 String、数值类型、bool、Time
-
-SDK 会在本地对数据格式做校验，如果希望跳过本地校验，可以在调用 track 接口的时候传入 skip_local_check 参数.
-
-#### 2. 设置公共事件属性
-公共事件属性是每个事件都会包含的属性. 也可以设置动态公共属性。如果有相同的属性，则动态公共属性会覆盖公共事件属性。
-
-```ruby
-# 定义公共属性
-super_properties = {
-  super_string: 'super_string',
-  super_int: 1,
-  super_bool: false,
-  super_date: Time.rfc2822("Thu, 26 Oct 2019 02:26:12 +0545") 
-}
-
-# 设置公共事件属性，公共事件属性会添加到每个事件中
-ta.set_super_properties(super_properties)
-
-# 清空公共事件属性
-ta.clear_super_properties
-```
-
-#### 3. 设置用户属性
-对于一般的用户属性，您可以调用 user_set 来进行设置. 使用该接口上传的属性将会覆盖原有的属性值，如果之前不存在该用户属性，则会新建该用户属性:
-```ruby
-# 定义用户属性数据
-user_data = {
-	# 账号 ID （可选)
-	account_id: 'ruby_test_aid',
-	# 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
-	distinct_id: 'ruby_distinct_id',
-	# 用户属性
-  properties: {
-    prop_date: Time.now,
-    prop_double: 134.12,
-    prop_string: 'hello',
-    prop_int: 666,
-	},
-}
-
-# 设置用户属性
-ta.user_set(user_data);
-```
-如果您要上传的用户属性只要设置一次，则可以调用 user_set_once 来进行设置，当该属性之前已经有值的时候，将会忽略这条信息:
-```ruby
-# 设置用户属性，如果已有同名属性，则忽略新设置属性
-ta.user_set_once(user_data);
-```
-当您要上传数值型的属性时，可以调用 user_add 来对该属性进行累加操作，如果该属性还未被设置，则会赋值 0 后再进行计算:
-```ruby
-# 对数值类型的属性进行累加操作
-ta.user_add(distinct_id: 'ruby_distinct_id', properties: {prop_int: 10, prop_double: 15.88})
-```
-
-当您需要删除某个用户属性的值时，可以调用 user_unset.
-```ruby
-# 删除某个用户属性
-ta.user_unset(distinct_id: 'ruby_distinct_id', property: :prop_string)
-
-# 删除一组用户属性
-ta.user_unset(distinct_id: 'ruby_distinct_id', property: Array.[](:prop_a, :prop_b, :prob_c))
-```
-
-如果您要删除某个用户，可以调用 user_del 将这名用户删除. 之后您将无法再查询该用户的用户属性，但该用户产生的事件仍然可以被查询到:
-```ruby
-# 删除用户
-ta.user_del(
-	# 账号 ID （可选)
-	account_id: 'ruby_test_aid',
-	# 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
-	distinct_id: 'ruby_distinct_id',
-);
-```
-
-#### 4. 立即进行数据 IO
-此操作与具体的 Consumer 实现有关. 在收到数据时, Consumer 可以先将数据存放在缓冲区, 并在特定情况下触发真正的数据 IO 操作, 以提高整体性能. 在某些情况下需要立即提交数据，可以调用 flush 接口:
-```ruby
-# 立即提交数据到相应的接收端
-ta.flush
-```
-
-#### 5. 关闭 SDK
-请在退出程序前调用本接口，以避免缓存内的数据丢失:
-```ruby
-# 关闭并退出 SDK
-ta.close
-```
-
-#### 6 其他说明
-默认情况下，除初始化参数不合法外，其他 Error 会被忽略，如果您希望自己处理接口调用中的 Error，可以传入自定义的 error handler.
-
-```ruby
-# (可选) 定义一个错误处理器，当出现 Error 时会调用
-class MyErrorHandler < TDAnalytics::ErrorHandler
-  def handle(error)
-      puts error
-      raise error
-  end
-end
-my_error_handler = MyErrorHandler.new
-
-# 创建 TA 实例, 第一个参数为任意一种 Consumer， 第二个参数可选，如果设定了会在出错时调用
-ta = TDAnalytics::Tracker.new(consumer, my_error_handler, uuid: true)
-```
-uuid 如果为 true，每条数据都会被带上随机 UUID 作为 #uuid 属性的值上报，该值不会入库，仅仅用于后台做数据重复检测.
+---

data/demo/demo.rb

@@ -2,19 +2,13 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
 require 'thinkingdata-ruby'
 require 'time'
-#require 'pry'
 
 if __FILE__ == $0
-  # 替换 DEMO_APPID 为您项目的 APP ID
-  DEMO_APPID = 'APPID'
-  # 替换 SERVER_URL 为您项目的 URL
-  SERVER_URL = 'https://sdk.tga.thinkinggame.cn'
-  # 账号 ID
-  DEMO_ACCOUNT_ID = 'ruby_demo_aid'
-  # 访客 ID
-  DEMO_DISTINCT_ID = 'ruby_demo_did'
-
-  # (可选) 定义一个错误处理器，当出现 Error 时会调用
+  DEMO_APPID = 'app id'
+  SERVER_URL = 'server url'
+  DEMO_ACCOUNT_ID = '123'
+  DEMO_DISTINCT_ID = 'aaa'
+
   class MyErrorHandler < TDAnalytics::ErrorHandler
     def handle(error)
       puts error
@@ -23,120 +17,89 @@ if __FILE__ == $0
   end
   my_error_handler = MyErrorHandler.new
 
-  # 定义 consumer: consumer 实现了 add、flush、close 等接口，将经过 SDK 格式化的数据以不同的方式存储或者发送到接收端
+  TDAnalytics::set_stringent(false)
+  TDAnalytics::set_enable_log(true)
+
   consumer = nil
-  $ARGV = 1
+  $ARGV = 0
   case $ARGV
   when 0
-    # LoggerConsumer，数据将写入本地文件(当前目录，按小时切分，前缀为 demolog)，需要配合 Logbus 上传数据到 TA 服务器
-    consumer = TDAnalytics::LoggerConsumer.new '.', 'hourly', prefix: 'demolog'
+    consumer = TDAnalytics::LoggerConsumer.new './log', 'hourly'
   when 1
-    # DebugConsumer，数据将被逐条同步的上报到 TA 服务器。出错时会返回详细的错误信息
-    consumer = TDAnalytics::DebugConsumer.new(SERVER_URL, DEMO_APPID)
-    # 如果不想上传到TA，只想校验数据格式，可以如下初始化
+    consumer = TDAnalytics::DebugConsumer.new(SERVER_URL, DEMO_APPID, device_id: "123456789")
     # consumer = TDAnalytics::DebugConsumer.new(SERVER_URL, DEMO_APPID,false)
   when 2
-    # BatchConsumer，数据将先存入缓冲区，达到指定条数时上报，默认为 20 条
     consumer = TDAnalytics::BatchConsumer.new(SERVER_URL, DEMO_APPID, 30)
-    #设置是否压缩数据，默认gzip压缩，内网可以这样设置
     #consumer._set_compress(false)
   else
-    # LoggerConsumer，数据将写入本地文件(当前目录，按天切分，前缀为 tda.log)，需要配合 Logbus 上传数据到 TA 服务器
     consumer = TDAnalytics::LoggerConsumer.new
   end
 
-  # 创建 TA 实例, 第一个参数为任意一种 Consumer， 第二个参数可选，如果设定了会在出错时调用
   ta = TDAnalytics::Tracker.new(consumer, my_error_handler, uuid: true)
 
-  # 定义公共属性
   super_properties = {
       super_string: 'super_string',
       super_int: 1,
       super_bool: false,
-      super_date: Time.rfc2822("Thu, 26 Oct 2019 02:26:12 +0545")
+      super_date: Time.rfc2822("Thu, 26 Oct 2019 02:26:12 +0545"),
+      '#app_id': "123123123123123"
   }
 
-  # 设置公共事件属性，公共事件属性会添加到每个事件中
   ta.set_super_properties(super_properties)
 
-  # 定义事件数据
-  event = {
-      # 事件名称 （必填)
-      event_name: 'test_event',
-      # 账号 ID （可选)
-      account_id: DEMO_ACCOUNT_ID,
-      # 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
-      distinct_id: DEMO_DISTINCT_ID,
-      # 事件时间 (可选) 如果不填，将以调用接口时的时间作为事件时间
-      time: Time.now,
-      # 事件 IP (可选) 当传入 IP 地址时，后台可以解析所在地
-      ip: '202.38.64.1',
-      # 事件属性 (可选)
-      properties: {
-          array: ["str1", "11", "22.22", "2020-02-11 17:02:52.415"],
-          prop_date: Time.now,
-          prop_double: 134.1,
-          prop_string: 'hello world',
-          prop_bool: true,
-      },
+  properties = {
+    array: ["str1", "11", Time.now, "2020-02-11 17:02:52.415"],
+    prop_date: Time.now,
+    prop_double: 134.1,
+    prop_string: 'hello world',
+    prop_bool: true,
+    '#ip': '123.123.123.123',
+    '#uuid': 'aaabbbccc',
   }
 
-  # 上报事件
-  5.times do
-    ta.track(event)
-    ta.clear_super_properties
+  ta.set_dynamic_super_properties do
+    {:dynamic_time => Time.now}
   end
 
-  # 定义用户属性数据
+  ta.track(event_name: 'test_event', distinct_id: DEMO_DISTINCT_ID, account_id: DEMO_ACCOUNT_ID, properties: properties)
+
+  ta.clear_dynamic_super_properties
+  ta.clear_super_properties
+
+  ta.track(event_name: 'test_event', distinct_id: DEMO_DISTINCT_ID, account_id: DEMO_ACCOUNT_ID, properties: properties)
+
   user_data = {
-      # 账号 ID （可选)
-      account_id: DEMO_ACCOUNT_ID,
-      # 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
-      distinct_id: DEMO_DISTINCT_ID,
-      # 用户属性
-      properties: {
-          array: ["str1", 11, 22.22],
-          prop_date: Time.now,
-          prop_double: 134.12,
-          prop_string: 'hello',
-          prop_int: 666,
-      },
+    array: ["str1", 11, 22.22],
+    prop_date: Time.now,
+    prop_double: 134.12,
+    prop_string: 'hello',
+    prop_int: 666,
   }
-  # 设置用户属性, 覆盖同名属性
-  ta.user_set(user_data)
-
-  #追加user的一个或者多个列表的属性
-  user_data_arr = {
-      # 账号 ID （可选)
-      account_id: DEMO_ACCOUNT_ID,
-      # 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
-      distinct_id: DEMO_DISTINCT_ID,
-      # 用户属性
-      properties: {
-          array: ["33", "44"],
-      },
+  ta.user_set(distinct_id: DEMO_DISTINCT_ID, account_id: DEMO_ACCOUNT_ID, properties: user_data)
+
+  user_append_data = {
+    array: %w[33 44]
   }
+  ta.user_append(distinct_id: DEMO_DISTINCT_ID, account_id: DEMO_ACCOUNT_ID, properties: user_append_data)
 
-  ta.user_append(user_data_arr)
+  user_uniq_append_data = {
+    array: %w[44 55]
+  }
+  ta.user_uniq_append(distinct_id: DEMO_DISTINCT_ID, account_id: DEMO_ACCOUNT_ID, properties: user_uniq_append_data)
 
-  # 设置用户属性，不会覆盖已经设置的同名属性
-  user_data[:properties][:prop_int_new] = 800
-  ta.user_set_once(user_data)
+  user_set_once_data = {
+    prop_int_new: 888,
+  }
+  ta.user_set_once(distinct_id: DEMO_DISTINCT_ID, account_id: DEMO_ACCOUNT_ID, properties: user_set_once_data)
 
-  # 累加用户属性
   ta.user_add(distinct_id: DEMO_DISTINCT_ID, properties: {prop_int: 10, prop_double: 15.88})
 
-
-  # 删除某个用户属性
   ta.user_unset(distinct_id: DEMO_DISTINCT_ID, property: [:prop_string, :prop_int])
 
+  ta.user_del(distinct_id: DEMO_DISTINCT_ID)
 
-  # 删除用户。此操作之前的事件数据不会被删除
-  # ta.user_del(distinct_id: DEMO_DISTINCT_ID)
-
-  #binding.pry
+  ta.flush
 
-  # 退出前调用此接口
   ta.close
 end
 

data/lib/thinkingdata-ruby/batch_consumer.rb

@@ -2,13 +2,13 @@ require 'json'
 require 'net/http'
 
 module TDAnalytics
-  # BatchConsumer 批量同步的发送数据.
-  # 有数据时，首先会加入本地缓冲区，当条数到达上限后会发起上报
   class BatchConsumer
-    # 默认缓冲区大小
-    MAX_LENGTH = 20
 
-    def initialize(server_url, app_id, max_buffer_length = MAX_LENGTH)
+    # 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
@@ -43,7 +43,13 @@ module TDAnalytics
             data = chunk.to_json
           end
           compress_type = @compress ? 'gzip' : 'none'
-          headers = {'Content-Type' => 'application/plaintext', 'appid' => @app_id, 'compress' => compress_type}
+          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
 
@@ -86,7 +92,6 @@ module TDAnalytics
     end
   end
 
-  # 内部使用，为了兼容老版本服务端，将 Header 名称限定为小写
   class CaseSensitivePost < Net::HTTP::Post
     def initialize_http_header(headers)
       @header = {}

data/lib/thinkingdata-ruby/debug_consumer.rb

@@ -2,22 +2,34 @@ require 'json'
 require 'net/http'
 
 module TDAnalytics
-  # DebugConsumer 逐条、同步地向服务端上报数据
-  # DebugConsumer 会返回详细的报错信息，建议在集成阶段先使用 DebugConsumer 调试接口
+  # The data is reported one by one, and when an error occurs, the log will be printed on the console.
   class DebugConsumer
 
-    def initialize(server_url, app_id, write_data = true)
+    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)
+        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
@@ -36,8 +48,8 @@ module TDAnalytics
       end
     end
 
-    def request(uri, form_data)
-      request = Net::HTTP::Post.new(uri.request_uri)
+    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)

data/lib/thinkingdata-ruby/errors.rb

@@ -1,21 +1,16 @@
 module TDAnalytics
 
-  # TD Analytics SDK 的错误
   TDAnalyticsError = Class.new(StandardError)
 
-  # 参数不合法
   IllegalParameterError = Class.new(TDAnalyticsError)
   
-  # 网络连接错误
   ConnectionError = Class.new(TDAnalyticsError)
   
-  # 服务器返回错误
   ServerError = Class.new(TDAnalyticsError)
 
 
-  # 默认情况下，所有异常都不会被抛出。如果希望自己处理异常，可以实现继承自 ErrorHandler 的
-  # 错误处理类，并在初始化 SDK 的时候作为参数传入.
-  # 例如: 
+  # use example:
+  #
   #    class MyErrorHandler < TDAnalytics::ErrorHandler
   #      def handle(error)
   #          puts error

data/lib/thinkingdata-ruby/logger_consumer.rb

@@ -2,14 +2,25 @@ require 'logger'
 require 'thinkingdata-ruby/errors'
 
 module TDAnalytics
-  # 将数据写入本地文件, 需配合 LogBus 将数据上传到服务器
-  # 由于 LogBus 有完善的失败重传机制，因此建议用户首先考虑此方案
+
+  # 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
-    # LoggerConsumer 构造函数
-    #   log_path: 日志文件存放目录
-    #   mode: 日志文件切分模式，可选 daily/hourly
-    #   prefix: 日志文件前缀，默认为 'tda.log', 日志文件名格式为: tda.log.2019-11-15
-    def initialize(log_path='.', mode='daily', prefix:'tda.log')
+
+    def initialize(log_path='.', mode='daily', prefix:'te.log')
       case mode
       when 'hourly'
         @suffix_mode = '%Y-%m-%d-%H'
@@ -22,9 +33,8 @@ module TDAnalytics
       raise IllegalParameterError.new("prefix couldn't be empty") if prefix.nil? || prefix.length == 0
 
       @current_suffix = Time.now.strftime(@suffix_mode)
-
-      @full_prefix = "#{log_path}/#{prefix}."
-
+      @log_path = log_path
+      @full_prefix = "#{log_path}/#{prefix}"
       _reset
     end
 
@@ -37,17 +47,16 @@ module TDAnalytics
       @logger.info(msg.to_json)
     end
   
-    # 关闭 logger
     def close
       @logger.close
     end
 
     private
 
-    # 重新创建 logger 对象. LogBus 判断新文件会同时考虑文件名和 inode，因此默认的切分方式会导致数据重传
     def _reset
-      @logger = Logger.new("#{@full_prefix}#{@current_suffix}")
-      @logger.level = Logger::INFO
+      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

data/lib/thinkingdata-ruby/tracker.rb

@@ -3,34 +3,39 @@ require 'thinkingdata-ruby/errors'
 require 'thinkingdata-ruby/version'
 
 module TDAnalytics
-  # TDAnalytics::Tracker 是数据上报的核心类，使用此类上报事件数据和更新用户属性.
-  # 创建 Tracker 类需要传入 consumer 对象，consumer 决定了如何处理格式化的数据（存储在本地日志文件还是上传到服务端).
-  #
-  #   ta = TDAnalytics::Tracker.new(consumer)
-  #   ta.track('your_event', distinct_id: 'distinct_id_of_user')
-  #
-  # TDAnalytics 提供了三种 consumer 实现:
-  #   LoggerConsumer: 数据写入本地文件
-  #   DebugConsumer: 数据逐条、同步的发送到服务端，并返回详细的报错信息
-  #   BatchConsumer: 数据批量、同步的发送到服务端
-  #
-  # 您也可以传入自己实现的 Consumer，只需实现以下接口:
-  #   add(message): 接受 hash 类型的数据对象
-  #   flush: (可选) 将缓冲区的数据发送到指定地址
-  #   close: (可选) 程序退出时用户可以主动调用此接口以保证安全退出
-  class Tracker
+  @is_enable_log = false
+  @is_stringent = false
+
+  def self.set_enable_log(enable)
+    unless [true, false].include? enable
+      enable = false
+    end
+    @is_enable_log = enable
+  end
+
+  def self.get_enable_log
+    @is_enable_log
+  end
+
+  def self.set_stringent(enable)
+    unless [true, false].include? enable
+      enable = false
+    end
+    @is_stringent = enable
+  end
+
+  def self.get_stringent
+    @is_stringent
+  end
 
+  class Tracker
     LIB_PROPERTIES = {
       '#lib' => 'ruby',
       '#lib_version' => TDAnalytics::VERSION,
     }
 
-    # SDK 构造函数，传入 consumer 对象
-    #
-    # 默认情况下，除参数不合法外，其他 Error 会被忽略，如果您希望自己处理接口调用中的 Error，可以传入自定义的 error handler.
-    # ErrorHandler 的定义可以参考 thinkingdata-ruby/errors.rb
-    #
-    # uuid 如果为 true，每条数据都会被带上随机 UUID 作为 #uuid 属性的值上报，该值不会入库，仅仅用于后台做数据重复检测
+    @@dynamic_block = nil
+
     def initialize(consumer, error_handler = nil, uuid: false)
       @error_handler = error_handler || ErrorHandler.new
       @consumer = consumer
@@ -38,10 +43,9 @@ module TDAnalytics
       @uuid = uuid
     end
 
-    # 设置公共事件属性，公共事件属性是所有事件都会带上的属性. 此方法会将传入的属性与当前公共属性合并.
-    # 如果希望跳过本地格式校验，可以传入值为 true 的 skip_local_check 参数
+    # set common properties
     def set_super_properties(properties, skip_local_check = false)
-      unless skip_local_check || _check_properties(:track, properties)
+      unless TDAnalytics::get_stringent == false || skip_local_check || _check_properties(:track, properties)
         @error_handler.handle(IllegalParameterError.new("Invalid super properties"))
         return false
       end
@@ -54,20 +58,28 @@ module TDAnalytics
       end
     end
 
-    # 清除公共事件属性
     def clear_super_properties
       @super_properties = {}
     end
 
-    # 上报事件. 每个事件都包含一个事件名和 Hash 对象的时间属性. 其参数说明如下:
-    #   event_name: (必须) 事件名 必须是英文字母开头，可以包含字母、数字和 _, 长度不超过 50 个字符.
-    #   distinct_id: (可选) 访客 ID
-    #   account_id: （可选) 账号ID distinct_id 和 account_id 不能同时为空
-    #   properties: （可选) Hash 事件属性。支持四种类型的值：字符串、数值、Time、boolean
-    #   time: （可选）Time 事件发生时间，如果不传默认为系统当前时间
-    #   ip: (可选) 事件 IP，如果传入 IP 地址，后端可以通过 IP 地址解析事件发生地点
-    #   skip_local_check: (可选) boolean 表示是否跳过本地检测
-    def track(event_name: nil, distinct_id: nil, account_id: nil, properties: {}, time: nil, ip: nil, skip_local_check: false)
+    def set_dynamic_super_properties(&block)
+      @@dynamic_block = block
+    end
+
+    def clear_dynamic_super_properties
+      @@dynamic_block = nil
+    end
+
+    # report ordinary event
+    #   event_name: (require) A string of 50 letters and digits that starts with '#' or a letter
+    #   distinct_id: (optional) distinct ID
+    #   account_id: (optional) account ID. distinct_id, account_id can't both be empty.
+    #   properties: （optional) string、number、Time、boolean
+    #   time: （optional）Time
+    #   ip: (optional) ip
+    #   first_check_id: (optional) The value cannot be null for the first event
+    #   skip_local_check: (optional) check data or not
+    def track(event_name: nil, distinct_id: nil, account_id: nil, properties: {}, time: nil, ip: nil,first_check_id:nil, skip_local_check: false)
       begin
         _check_name event_name
         _check_id(distinct_id, account_id)
@@ -79,21 +91,44 @@ module TDAnalytics
         return false
       end
 
-      data = {}
-      data[:event_name] = event_name
-      data[:distinct_id] = distinct_id if distinct_id
-      data[:account_id] = account_id if account_id
-      data[:time] = time if time
-      data[:ip] = ip if ip
-      data[:properties] = properties
+      _internal_track(:track, event_name: event_name, distinct_id: distinct_id, account_id: account_id, properties: properties, time: time, ip: ip, first_check_id: first_check_id)
+    end
 
-      _internal_track(:track, data)
+    # report overridable event
+    def track_overwrite(event_name: nil,event_id: nil, distinct_id: nil, account_id: nil, properties: {}, time: nil, ip: nil, skip_local_check: false)
+      begin
+        _check_name event_name
+        _check_event_id event_id
+        _check_id(distinct_id, account_id)
+        unless skip_local_check
+          _check_properties(:track_overwrite, properties)
+        end
+      rescue TDAnalyticsError => e
+        @error_handler.handle(e)
+        return false
+      end
+
+      _internal_track(:track_overwrite, event_name: event_name, event_id: event_id, distinct_id: distinct_id, account_id: account_id, properties: properties, time: time, ip: ip)
     end
 
-    # 设置用户属性. 如果出现同名属性，则会覆盖之前的值.
-    #   distinct_id: (可选) 访客 ID
-    #   account_id: （可选) 账号ID distinct_id 和 account_id 不能同时为空
-    #   properties: （可选) Hash 用户属性。支持四种类型的值：字符串、数值、Time、boolean
+    # report updatable event
+    def track_update(event_name: nil,event_id: nil, distinct_id: nil, account_id: nil, properties: {}, time: nil, ip: nil, skip_local_check: false)
+      begin
+        _check_name event_name
+        _check_event_id event_id
+        _check_id(distinct_id, account_id)
+        unless skip_local_check
+          _check_properties(:track_update, properties)
+        end
+      rescue TDAnalyticsError => e
+        @error_handler.handle(e)
+        return false
+      end
+
+      _internal_track(:track_update, event_name: event_name, event_id: event_id, distinct_id: distinct_id, account_id: account_id, properties: properties, time: time, ip: ip)
+    end
+
+    # set user properties. would overwrite existing names.
     def user_set(distinct_id: nil, account_id: nil, properties: {}, ip: nil)
       begin
         _check_id(distinct_id, account_id)
@@ -103,15 +138,10 @@ module TDAnalytics
         return false
       end
 
-      _internal_track(:user_set,
-                      distinct_id: distinct_id,
-                      account_id: account_id,
-                      properties: properties,
-                      ip: ip,
-      )
+      _internal_track(:user_set, distinct_id: distinct_id, account_id: account_id, properties: properties, ip: ip)
     end
 
-    # 设置用户属性. 如果有重名属性，则丢弃, 参数与 user_set 相同
+    # set user properties, If such property had been set before, this message would be neglected.
     def user_set_once(distinct_id: nil, account_id: nil, properties: {}, ip: nil)
       begin
         _check_id(distinct_id, account_id)
@@ -129,7 +159,7 @@ module TDAnalytics
       )
     end
 
-    # 追加用户的一个或多个列表类型的属性
+    # to add user properties of array type.
     def user_append(distinct_id: nil, account_id: nil, properties: {})
       begin
         _check_id(distinct_id, account_id)
@@ -146,7 +176,23 @@ module TDAnalytics
                       )
     end
 
-    # 删除用户属性, property 可以传入需要删除的用户属性的 key 值，或者 key 值数组
+    def user_uniq_append(distinct_id: nil, account_id: nil, properties: {})
+      begin
+        _check_id(distinct_id, account_id)
+        _check_properties(:user_uniq_append, properties)
+      rescue TDAnalyticsError => e
+        @error_handler.handle(e)
+        return false
+      end
+
+      _internal_track(:user_uniq_append,
+                      distinct_id: distinct_id,
+                      account_id: account_id,
+                      properties: properties,
+                      )
+    end
+
+    # clear the user properties of users.
     def user_unset(distinct_id: nil, account_id: nil, property: nil)
       properties = {}
       if property.is_a?(Array)
@@ -172,10 +218,7 @@ module TDAnalytics
       )
     end
 
-    # 累加用户属性, 如果用户属性不存在，则会设置为 0，然后再累加
-    #   distinct_id: (可选) 访客 ID
-    #   account_id: （可选) 账号ID distinct_id 和 account_id 不能同时为空
-    #   properties: （可选) Hash 数值类型的用户属性
+    # to accumulate operations against the property.
     def user_add(distinct_id: nil, account_id: nil, properties: {})
       begin
         _check_id(distinct_id, account_id)
@@ -192,7 +235,7 @@ module TDAnalytics
       )
     end
 
-    # 删除用户，用户之前的事件数据不会被删除
+    # delete a user, This operation cannot be undone.
     def user_del(distinct_id: nil, account_id: nil)
       begin
         _check_id(distinct_id, account_id)
@@ -207,7 +250,7 @@ module TDAnalytics
       )
     end
 
-    # 立即上报数据，对于 BatchConsumer 会触发上报
+    # report data immediately.
     def flush
       return true unless defined? @consumer.flush
       ret = true
@@ -220,7 +263,7 @@ module TDAnalytics
       ret
     end
 
-    # 退出前调用，保证 Consumer 安全退出
+    # Close and exit sdk
     def close
       return true unless defined? @consumer.close
       ret = true
@@ -235,35 +278,39 @@ module TDAnalytics
 
     private
 
-    # 出现异常的时候返回 false, 否则 true
-    def _internal_track(type, properties: {}, event_name: nil, account_id: nil, distinct_id: nil, ip: nil, time: Time.now)
-      if account_id == nil && distinct_id == nil
-        raise IllegalParameterError.new('account id or distinct id must be provided.')
+    def _internal_track(type, properties: {}, event_name: nil, event_id:nil, account_id: nil, distinct_id: nil, ip: nil,first_check_id: nil, time: nil)
+      if type == :track || type == :track_update || type == :track_overwrite
+        dynamic_properties = @@dynamic_block.respond_to?(:call) ? @@dynamic_block.call : {}
+        properties = LIB_PROPERTIES.merge(@super_properties).merge(dynamic_properties).merge(properties)
       end
 
-      if type == :track
-        raise IllegalParameterError.new('event name is empty for track') if event_name == nil
-        properties = {'#zone_offset': time.utc_offset / 3600.0}.merge(LIB_PROPERTIES).merge(@super_properties).merge(properties)
-      end
+      data = {
+        '#type' => type,
+      }
 
-      # 格式化 Time 类型
       properties.each do |k, v|
         if v.is_a?(Time)
           properties[k] = _format_time(v)
         end
       end
 
-      data = {
-          '#type' => type,
-          '#time' => _format_time(time),
-          'properties' => properties,
-      }
+      _move_preset_properties([:'#ip', :"#time", :"#app_id", :"#uuid"], data, properties: properties)
+
+      if data[:'#time'] == nil
+        if time == nil
+          time = Time.now
+        end
+        data[:'#time'] = _format_time(time)
+      end
 
-      data['#event_name'] = event_name if type == :track
+      data['properties'] = properties
+      data['#event_name'] = event_name if (type == :track || type == :track_update || type == :track_overwrite)
+      data['#event_id'] = event_id if (type == :track_update || type == :track_overwrite)
       data['#account_id'] = account_id if account_id
       data['#distinct_id'] = distinct_id if distinct_id
       data['#ip'] = ip if ip
-      data['#uuid'] = SecureRandom.uuid if @uuid
+      data['#first_check_id'] = first_check_id if first_check_id
+      data[:'#uuid'] = SecureRandom.uuid if @uuid and data[:'#uuid'] == nil
 
       ret = true
       begin
@@ -276,33 +323,44 @@ module TDAnalytics
       ret
     end
 
-    # 将 Time 类型格式化为数数指定格式的字符串
     def _format_time(time)
       time.strftime("%Y-%m-%d %H:%M:%S.#{((time.to_f * 1000.0).to_i % 1000).to_s.rjust(3, "0")}")
     end
 
-    # 属性名或者事件名检查
+    def _check_event_id(event_id)
+      if TDAnalytics::get_stringent == false
+        return true
+      end
+
+      raise IllegalParameterError.new("the event_id or property cannot be nil") if event_id.nil?
+      true
+    end
+
     def _check_name(name)
+      if TDAnalytics::get_stringent == false
+        return true
+      end
+
       raise IllegalParameterError.new("the name of event or property cannot be nil") if name.nil?
 
       unless name.instance_of?(String) || name.instance_of?(Symbol)
         raise IllegalParameterError.new("#{name} is invalid. It must be String or Symbol")
       end
-
-      unless name =~ /^[a-zA-Z][a-zA-Z0-9_]{1,49}$/
-        raise IllegalParameterError.new("#{name} is invalid. It must be string starts with letters and contains letters, numbers, and _ with max length of 50")
-      end
       true
     end
 
-    # 属性类型检查
     def _check_properties(type, properties)
+      if TDAnalytics::get_stringent == false
+        return true
+      end
+
       unless properties.instance_of? Hash
         return false
       end
 
       properties.each do |k, v|
         _check_name k
+        next if v.nil?
         unless v.is_a?(Integer) || v.is_a?(Float) || v.is_a?(Symbol) || v.is_a?(String) || v.is_a?(Time) || !!v == v || v.is_a?(Array)
           raise IllegalParameterError.new("The value of properties must be type in Integer, Float, Symbol, String, Array,and Time")
         end
@@ -321,16 +379,30 @@ module TDAnalytics
       true
     end
 
-    # 检查用户 ID 合法性
     def _check_id(distinct_id, account_id)
+      if TDAnalytics::get_stringent == false
+        return true
+      end
+
       raise IllegalParameterError.new("account id or distinct id must be provided.") if distinct_id.nil? && account_id.nil?
+    end
 
-      unless distinct_id.nil?
-        raise IllegalParameterError.new("The length of distinct id should in (0, 64]") if distinct_id.to_s.length < 1 || distinct_id.to_s.length > 64
-      end
+    def _move_preset_properties(keys, data, properties: {})
+      property_keys = properties.keys
+      keys.each { |k|
+        if property_keys.include? k
+          data[k] = properties[k]
+          properties.delete(k)
+        end
+      }
+    end
+  end
 
-      unless account_id.nil?
-        raise IllegalParameterError.new("The length of account id should in (0, 64]") if account_id.to_s.length < 1 || account_id.to_s.length > 64
+  class TELog
+    def self.info(*msg)
+      if TDAnalytics::get_enable_log
+        print("[ThinkingEngine][#{Time.now}][info]-")
+        puts(msg)
       end
     end
   end

data/lib/thinkingdata-ruby/version.rb

@@ -1,3 +1,3 @@
 module TDAnalytics
-  VERSION = '1.1.0'
+  VERSION = '1.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thinkingdata-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - ThinkingData
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-11 00:00:00.000000000 Z
+date: 2023-03-21 00:00:00.000000000 Z
 dependencies: []
 description: The official ThinkingData Analytics API for ruby
 email: sdk@thinkingdata.cn
@@ -16,6 +16,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -48,8 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.9
 signing_key: 
 specification_version: 4
 summary: Official ThinkingData Analytics API for ruby