trifle-stats 2.4.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 574331154d00b65ea5a994f7c7fbc754a1225c39617294acbeed3886c88d5b98
-  data.tar.gz: d4cca3dd912c0642594805395f727fcce350cee4cd6b388ddf09fb3032895317
+  metadata.gz: '014813aa6a45f6fece54f7fc332272c85023a37236cd3b4eeb270f3f00fed3a0'
+  data.tar.gz: f83d0bfecc64f03cd3160e3762eb09a12d76ea8c9cda78c8108ee063bd8caf50
 SHA512:
-  metadata.gz: 423c591af0e2f61178be6553afef6ec4a52ab96268f30b82720e8bf591d079ece3b5b4753766f1ebeecffe442b92162ea89619a4aa7fa58298aee62b226f1cba
-  data.tar.gz: a1fdba88136d21091e95eb59b1b87fab7e917626e40860d5e7128f7771c0428547e2070ba98ae8a9cf5437ee5d61c7671745336226fc25c46492fd6aee1756f1
+  metadata.gz: 71ecb7d927d16ec3f29fec1f57624b8f72bb482841a7a6c0d948ddf8ddc42b0d8b88b858f12436a330189a0731ba41d9514332cfc25e4721c3b7387f11d1c809
+  data.tar.gz: da222c50726b1241f2fbfe86c21553c1fea4393c80e53c065e94ea4895fbf755fb6f1e59d15b61b3d1219d114fb444b1bc4eb935b21e9970a4b704b0348a23fc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    trifle-stats (2.4.1)
+    trifle-stats (2.5.0)
       tzinfo (~> 2.0)
 
 GEM

data/README.md

@@ -57,6 +57,25 @@ Trifle::Stats.values(
 #=> { at: [Mon, Tue, Wed, ...], values: [{ "count" => 12, "revenue" => 598_80, ... }, ...] }
 ```
 
+### 5. Process with Series
+
+```ruby
+series = Trifle::Stats.series(
+  key: 'orders',
+  from: 1.week.ago,
+  to: Time.now,
+  granularity: :day
+)
+
+series.transpond.expression(
+  paths: ['revenue', 'count'],
+  expression: 'a / b',
+  response: 'avg_order'
+)
+
+series.aggregate.sum(path: 'count')
+```
+
 ## Drivers
 
 | Driver | Backend | Best for |
@@ -67,13 +86,12 @@ Trifle::Stats.values(
 | **MySQL** | JSON column | MySQL shops |
 | **SQLite** | JSON1 extension | Single-server apps, dev/test |
 | **Process** | In-memory | Testing |
-| **Dummy** | No-op | Disabled analytics |
 
 ## Features
 
 - **Dynamic time granularities.** Use any interval like `1m`, `10m`, `1h`, `6h`, `1d`, `1w`, `1mo`, `1q`, `1y`.
 - **Nested value hierarchies.** Track dimensional breakdowns in a single call.
-- **Series operations.** Aggregators (sum, avg, min, max), transponders, formatters.
+- **Series operations.** Aggregators, the expression transponder, and formatters.
 - **Buffered writes.** Queue metrics in-memory before flushing to reduce write load.
 - **Driver flexibility.** Switch backends without changing application code.
 

data/lib/trifle/stats/driver/mysql.rb

@@ -95,10 +95,9 @@ module Trifle
         end
 
         def get(keys:)
-          keys.map do |key|
-            identifier = identifier_for(key)
-            self.class.unpack(hash: fetch_packed_data(identifier))
-          end
+          identifiers = keys.map { |key| identifier_for(key) }
+          data = get_all(identifiers: identifiers)
+          identifiers.map { |identifier| self.class.unpack(hash: data.fetch(lookup_key_for(identifier), {})) }
         end
 
         def ping(key:, values:)
@@ -157,23 +156,42 @@ module Trifle
           execute_prepared(connection, query, args)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        def fetch_packed_data(identifier)
-          conditions = identifier.keys.map { |column| "#{self.class.quote_identifier(column)} = ?" }.join(' AND ')
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def get_all(identifiers:)
+          columns = identifiers.first.keys
+          # Select `at` as a plain string to avoid client time zone casting
+          columns_sql = columns.map do |column|
+            if column == :at
+              "DATE_FORMAT(`at`, '%Y-%m-%d %H:%i:%s.%f') AS at"
+            else
+              self.class.quote_identifier(column)
+            end
+          end.join(', ')
+          conditions = identifiers.map do |identifier|
+            "(#{identifier.keys.map { |column| "#{self.class.quote_identifier(column)} = ?" }.join(' AND ')})"
+          end.join(' OR ')
+
           query = <<~SQL
-            SELECT CAST(`data` AS CHAR) AS data
+            SELECT #{columns_sql}, CAST(`data` AS CHAR) AS data
             FROM #{self.class.quote_identifier(table_name)}
             WHERE #{conditions}
-            LIMIT 1
           SQL
-          packed_data = execute_prepared(client, query, query_values(identifier)).first&.fetch('data', nil)
-          return {} if packed_data.nil? || packed_data.empty?
+          args = identifiers.flat_map { |identifier| query_values(identifier) }
 
-          JSON.parse(packed_data)
-        rescue JSON::ParserError
-          {}
+          execute_prepared(client, query, args).each_with_object({}) do |row, o|
+            identifier = columns.to_h { |column| [column, row[column.to_s]] }
+            o[lookup_key_for(identifier)] = JSON.parse(row['data'])
+          rescue JSON::ParserError
+            nil
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def lookup_key_for(identifier)
+          identifier.map do |_column, value|
+            value.is_a?(Time) || value.is_a?(DateTime) ? format_time_value(value) : value.to_s
+          end.join('|')
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def inc_query(identifier:, data:)
           upsert_query(

data/lib/trifle/stats/driver/postgres.rb

@@ -61,22 +61,26 @@ module Trifle
           client.transaction do |c|
             keys.map do |key|
               identifier = identifier_for(key)
-              c.exec(inc_query(identifier: identifier, data: data))
+              query, params = inc_query(identifier: identifier, data: data)
+              c.exec_params(query, params)
               track_system_data(c, key, count, tracking_key)
             end
           end
         end
 
-        def inc_query(identifier:, data:)
+        def inc_query(identifier:, data:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           columns = identifier.keys.join(', ')
-          values = identifier.values.map { |v| format_value(v) }.join(', ')
-          conflict_columns = identifier.keys.join(', ')
+          placeholders = identifier.each_with_index.map { |_, i| "$#{i + 1}" }.join(', ')
+          expression = data.inject("to_jsonb(#{table_name}.data)") do |o, (k, v)|
+            path = escape_string(k.to_s)
+            "jsonb_set(#{o}, '{#{path}}', (COALESCE(#{table_name}.data->>'#{path}', '0')::numeric + #{numeric_value(k, v)})::text::jsonb)" # rubocop:disable Layout/LineLength
+          end
 
-          <<-SQL
-            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{values}, '#{data.to_json}')
-            ON CONFLICT (#{conflict_columns}) DO UPDATE SET data =
-            #{data.inject("to_jsonb(#{table_name}.data)") { |o, (k, v)| "jsonb_set(#{o}, '{#{k}}', (COALESCE(#{table_name}.data->>'#{k}', '0')::int + #{v})::text::jsonb)" }};
+          query = <<-SQL
+            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{placeholders}, $#{identifier.size + 1})
+            ON CONFLICT (#{columns}) DO UPDATE SET data = #{expression};
           SQL
+          [query, query_params(identifier) + [data.to_json]]
         end
 
         def set(keys:, values:, count: 1, tracking_key: nil)
@@ -84,7 +88,8 @@ module Trifle
           client.transaction do |c|
             keys.map do |key|
               identifier = identifier_for(key)
-              c.exec(set_query(identifier: identifier, data: data))
+              query, params = set_query(identifier: identifier, data: data)
+              c.exec_params(query, params)
               track_system_data(c, key, count, tracking_key)
             end
           end
@@ -94,21 +99,24 @@ module Trifle
           return unless @system_tracking
 
           system_data = system_data_for(key: key, count: count, tracking_key: tracking_key)
-          connection.exec(
-            inc_query(identifier: system_identifier_for(key: key), data: system_data)
-          )
+          query, params = inc_query(identifier: system_identifier_for(key: key), data: system_data)
+          connection.exec_params(query, params)
         end
 
-        def set_query(identifier:, data:)
+        def set_query(identifier:, data:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           columns = identifier.keys.join(', ')
-          values = identifier.values.map { |v| format_value(v) }.join(', ')
-          conflict_columns = identifier.keys.join(', ')
+          placeholders = identifier.each_with_index.map { |_, i| "$#{i + 1}" }.join(', ')
+          params = query_params(identifier) + [data.to_json]
+          expression = data.inject("to_jsonb(#{table_name}.data)") do |o, (k, v)|
+            params << v.to_json
+            "jsonb_set(#{o}, '{#{escape_string(k.to_s)}}', $#{params.size}::jsonb)"
+          end
 
-          <<-SQL
-            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{values}, '#{data.to_json}')
-            ON CONFLICT (#{conflict_columns}) DO UPDATE SET data =
-            #{data.inject("to_jsonb(#{table_name}.data)") { |o, (k, v)| "jsonb_set(#{o}, '{#{k}}', '#{v.to_json}'::jsonb)" }}
+          query = <<-SQL
+            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{placeholders}, $#{identifier.size + 1})
+            ON CONFLICT (#{columns}) DO UPDATE SET data = #{expression}
           SQL
+          [query, params]
         end
 
         def get(keys:)
@@ -118,7 +126,8 @@ module Trifle
         end
 
         def get_all(identifiers:) # rubocop:disable Metrics/AbcSize
-          results = client.exec_params(get_query(identifiers: identifiers)).to_a
+          query, params = get_query(identifiers: identifiers)
+          results = client.exec_params(query, params).to_a
           sample = identifiers.first
 
           results.each_with_object(Hash.new({})) do |r, o|
@@ -130,37 +139,44 @@ module Trifle
           end
         end
 
-        def get_query(identifiers:)
+        def get_query(identifiers:) # rubocop:disable Metrics/MethodLength
+          params = []
           conditions = identifiers.map do |identifier|
-            identifier.map { |k, v| "#{k} = #{format_value(v)}" }.join(' AND ')
+            identifier.map do |k, v|
+              params << query_param(v)
+              "#{k} = $#{params.size}"
+            end.join(' AND ')
           end.join(' OR ')
 
-          <<-SQL
+          query = <<-SQL
             SELECT * FROM #{table_name} WHERE #{conditions};
           SQL
+          [query, params]
         end
 
         def ping(key:, values:)
           return [] if @joined_identifier
 
           data = self.class.pack(hash: { data: values, at: key.at })
-          operation = ping_query(key: key.key, at: key.at, data: data)
+          query, params = ping_query(key: key.key, at: key.at, data: data)
           client.transaction do |c|
-            c.exec(operation)
+            c.exec_params(query, params)
           end
         end
 
         def ping_query(key:, at:, data:)
-          <<-SQL
-            INSERT INTO #{ping_table_name} (key, at, data) VALUES ('#{key}', '#{at.iso8601}', '#{data.to_json}')
-            ON CONFLICT (key) DO UPDATE SET at = '#{at.iso8601}', data = '#{data.to_json}'::jsonb;
+          query = <<-SQL
+            INSERT INTO #{ping_table_name} (key, at, data) VALUES ($1, $2, $3)
+            ON CONFLICT (key) DO UPDATE SET at = $2, data = $3::jsonb;
           SQL
+          [query, [key.to_s, at.iso8601, data.to_json]]
         end
 
         def scan(key:)
           return [] if @joined_identifier
 
-          result = client.exec_params(scan_query(key: key.key)).to_a.first
+          query, params = scan_query(key: key.key)
+          result = client.exec_params(query, params).to_a.first
           return [] if result.nil?
 
           [Time.parse(result['at']), self.class.unpack(hash: JSON.parse(result['data']))]
@@ -169,9 +185,10 @@ module Trifle
         end
 
         def scan_query(key:)
-          <<-SQL
-            SELECT at, data FROM #{ping_table_name} WHERE key = '#{key}' ORDER BY at DESC LIMIT 1;
+          query = <<-SQL
+            SELECT at, data FROM #{ping_table_name} WHERE key = $1 ORDER BY at DESC LIMIT 1;
           SQL
+          [query, [key.to_s]]
         end
 
         def self.normalize_joined_identifier(value)
@@ -185,19 +202,31 @@ module Trifle
 
         private
 
-        def format_value(value)
+        def query_params(identifier)
+          identifier.values.map { |value| query_param(value) }
+        end
+
+        def query_param(value)
           case value
-          when String
-            "'#{value}'"
           when Time
-            "'#{value.utc.strftime('%Y-%m-%d %H:%M:%S+00')}'"
+            value.utc.strftime('%Y-%m-%d %H:%M:%S+00')
           when Integer, Float
-            value.to_s
+            value
           else
-            "'#{value}'"
+            value.to_s
           end
         end
 
+        def numeric_value(key, value)
+          return value.to_s if value.is_a?(Numeric)
+
+          raise ArgumentError, "increment requires numeric value for key #{key.inspect}"
+        end
+
+        def escape_string(value)
+          value.gsub("'", "''")
+        end
+
         def build_map_key(data)
           return data[:key] if @joined_identifier == :full
           return "#{data[:key]}::#{data[:at]}" if @joined_identifier == :partial

data/lib/trifle/stats/driver/redis.rb

@@ -31,47 +31,43 @@ module Trifle
           self.class.pack(hash: { count: count, keys: { tracking_key => count } })
         end
 
-        def inc(keys:, values:, count: 1, tracking_key: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          keys.map do |key|
-            key.prefix = prefix
-            pkey = key.join(separator)
-
-            self.class.pack(hash: values).each do |k, c|
-              client.hincrby(pkey, k, c)
-            end
-            next unless @system_tracking
-
-            skey = system_join_for(key: key)
-            system_data_for(key: key, count: count, tracking_key: tracking_key).each do |k, c|
-              client.hincrby(skey, k, c)
+        def inc(keys:, values:, count: 1, tracking_key: nil) # rubocop:disable Metrics/MethodLength
+          packed = self.class.pack(hash: values)
+          client.pipelined do |pipeline|
+            keys.each do |key|
+              key.prefix = prefix
+              pkey = key.join(separator)
+
+              packed.each do |k, c|
+                pipeline.hincrby(pkey, k, c)
+              end
+              track_system_data(pipeline, key, count, tracking_key)
             end
           end
         end
 
         def set(keys:, values:, count: 1, tracking_key: nil)
-          keys.map do |key|
-            key.prefix = prefix
-            pkey = key.join(separator)
-
-            client.hmset(pkey, *self.class.pack(hash: values))
-            next unless @system_tracking
-
-            skey = system_join_for(key: key)
-            system_data_for(key: key, count: count, tracking_key: tracking_key).each do |k, c|
-              client.hincrby(skey, k, c)
+          packed = self.class.pack(hash: values)
+          client.pipelined do |pipeline|
+            keys.each do |key|
+              key.prefix = prefix
+              pkey = key.join(separator)
+
+              pipeline.hmset(pkey, *packed)
+              track_system_data(pipeline, key, count, tracking_key)
             end
           end
         end
 
         def get(keys:)
-          keys.map do |key|
-            key.prefix = prefix
-            pkey = key.join(separator)
-
-            self.class.unpack(
-              hash: client.hgetall(pkey)
-            )
+          results = client.pipelined do |pipeline|
+            keys.each do |key|
+              key.prefix = prefix
+              pipeline.hgetall(key.join(separator))
+            end
           end
+
+          results.map { |hash| self.class.unpack(hash: hash) }
         end
 
         def ping(*)
@@ -81,6 +77,17 @@ module Trifle
         def scan(*)
           []
         end
+
+        private
+
+        def track_system_data(pipeline, key, count, tracking_key)
+          return unless @system_tracking
+
+          skey = system_join_for(key: key)
+          system_data_for(key: key, count: count, tracking_key: tracking_key).each do |k, c|
+            pipeline.hincrby(skey, k, c)
+          end
+        end
       end
     end
   end

data/lib/trifle/stats/driver/sqlite.rb

@@ -70,16 +70,19 @@ module Trifle
           end
         end
 
-        def inc_query(identifier:, data:)
+        def inc_query(identifier:, data:) # rubocop:disable Metrics/MethodLength
           columns = identifier.keys.join(', ')
-          values = identifier.values.map { |v| format_value(v) }.join(', ')
-          conflict_columns = identifier.keys.join(', ')
+          placeholders = (['?'] * identifier.size).join(', ')
+          expression = data.inject('data') do |o, (k, v)|
+            path = json_path_for(k)
+            "json_set(#{o}, '#{path}', IFNULL(json_extract(data, '#{path}'), 0) + #{numeric_value(k, v)})"
+          end
 
-          <<-SQL
-            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{values}, json('#{data.to_json}'))
-            ON CONFLICT (#{conflict_columns}) DO UPDATE SET data =
-            #{data.inject('data') { |o, (k, v)| "json_set(#{o}, '$.#{k}', IFNULL(json_extract(data, '$.#{k}'), 0) + #{v})" }};
+          query = <<-SQL
+            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{placeholders}, json(?))
+            ON CONFLICT (#{columns}) DO UPDATE SET data = #{expression};
           SQL
+          [query, query_params(identifier) + [data.to_json]]
         end
 
         def set(keys:, values:, count: 1, tracking_key: nil)
@@ -104,16 +107,20 @@ module Trifle
           )
         end
 
-        def set_query(identifier:, data:)
+        def set_query(identifier:, data:) # rubocop:disable Metrics/MethodLength
           columns = identifier.keys.join(', ')
-          values = identifier.values.map { |v| format_value(v) }.join(', ')
-          conflict_columns = identifier.keys.join(', ')
+          placeholders = (['?'] * identifier.size).join(', ')
+          params = query_params(identifier) + [data.to_json]
+          expression = data.inject('data') do |o, (k, v)|
+            params << v.to_json
+            "json_set(#{o}, '#{json_path_for(k)}', json(?))"
+          end
 
-          <<-SQL
-            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{values}, json('#{data.to_json}'))
-            ON CONFLICT (#{conflict_columns}) DO UPDATE SET data =
-            #{data.inject('data') { |o, (k, v)| "json_set(#{o}, '$.#{k}', #{v.to_json})" }};
+          query = <<-SQL
+            INSERT INTO #{table_name} (#{columns}, data) VALUES (#{placeholders}, json(?))
+            ON CONFLICT (#{columns}) DO UPDATE SET data = #{expression};
           SQL
+          [query, params]
         end
 
         def get(keys:)
@@ -123,7 +130,8 @@ module Trifle
         end
 
         def get_all(identifiers:) # rubocop:disable Metrics/AbcSize
-          results = client.execute(get_query(identifiers: identifiers)).to_a
+          query, params = get_query(identifiers: identifiers)
+          results = client.execute(query, params).to_a
           sample = identifiers.first
 
           results.each_with_object(Hash.new({})) do |r, o|
@@ -136,38 +144,42 @@ module Trifle
         end
 
         def get_query(identifiers:)
+          params = []
           conditions = identifiers.map do |identifier|
-            identifier.map { |k, v| build_field_condition(k, v) }.join(' AND ')
+            identifier.map { |k, v| build_field_condition(k, v, params) }.join(' AND ')
           end.join(' OR ')
 
-          <<-SQL
+          query = <<-SQL
             SELECT * FROM #{table_name} WHERE #{conditions};
           SQL
+          [query, params]
         end
 
         def ping(key:, values:)
           return [] if @joined_identifier
 
           data = self.class.pack(hash: { data: values, at: key.at })
-          operation = ping_query(key: key.key, at: key.at, data: data)
+          query, params = ping_query(key: key.key, at: key.at, data: data)
           client.transaction do |c|
-            c.execute(operation) # TODO: should use batch_data_operations
+            c.execute(query, params) # TODO: should use batch_data_operations
           end
         end
 
         def ping_query(key:, at:, data:)
           at_formatted = format_time_value(at)
 
-          <<-SQL
-            INSERT INTO #{ping_table_name} (key, at, data) VALUES ('#{key}', '#{at_formatted}', json('#{data.to_json}'))
-            ON CONFLICT (key) DO UPDATE SET at = '#{at_formatted}', data = json('#{data.to_json}');
+          query = <<-SQL
+            INSERT INTO #{ping_table_name} (key, at, data) VALUES (?, ?, json(?))
+            ON CONFLICT (key) DO UPDATE SET at = ?, data = json(?);
           SQL
+          [query, [key.to_s, at_formatted, data.to_json, at_formatted, data.to_json]]
         end
 
         def scan(key:)
           return [] if @joined_identifier
 
-          result = client.execute(scan_query(key: key.key)).first
+          query, params = scan_query(key: key.key)
+          result = client.execute(query, params).first
           return [] if result.nil?
 
           # SQLite returns columns in order: key, at, data
@@ -177,9 +189,10 @@ module Trifle
         end
 
         def scan_query(key:)
-          <<-SQL
-            SELECT key, at, data FROM #{ping_table_name} WHERE key = '#{key}' ORDER BY at DESC LIMIT 1;
+          query = <<-SQL
+            SELECT key, at, data FROM #{ping_table_name} WHERE key = ? ORDER BY at DESC LIMIT 1;
           SQL
+          [query, [key.to_s]]
         end
 
         def self.normalize_joined_identifier(value)
@@ -193,13 +206,17 @@ module Trifle
 
         private
 
-        def build_field_condition(key, value)
-          return "#{key} = #{format_value(value)}" unless key == :at
+        def build_field_condition(key, value, params)
+          unless key == :at
+            params << query_param(value)
+            return "#{key} = ?"
+          end
 
           formatted = format_time_value(value)
-          with_microseconds = formatted.sub('Z', '.000000Z')
+          params << formatted
+          params << formatted.sub('Z', '.000000Z')
 
-          "(at = '#{formatted}' OR at = '#{with_microseconds}')"
+          '(at = ? OR at = ?)'
         end
 
         # Batch data operations to avoid SQLite parser stack overflow
@@ -209,16 +226,30 @@ module Trifle
           batch_size = 10
           data.each_slice(batch_size) do |batch|
             batch_data = batch.to_h
-            query = send("#{operation}_query", identifier: identifier, data: batch_data)
-            connection.execute(query)
+            query, params = send("#{operation}_query", identifier: identifier, data: batch_data)
+            connection.execute(query, params)
           end
         end
 
-        def format_value(value)
-          return "'#{format_time_value(value)}'" if value.is_a?(Time) || value.is_a?(DateTime)
-          return value.to_s if value.is_a?(Integer) || value.is_a?(Float)
+        def query_params(identifier)
+          identifier.values.map { |value| query_param(value) }
+        end
+
+        def query_param(value)
+          return format_time_value(value) if value.is_a?(Time) || value.is_a?(DateTime)
+          return value if value.is_a?(Integer) || value.is_a?(Float)
+
+          value.to_s
+        end
+
+        def numeric_value(key, value)
+          return value.to_s if value.is_a?(Numeric)
+
+          raise ArgumentError, "increment requires numeric value for key #{key.inspect}"
+        end
 
-          "'#{value}'"
+        def json_path_for(key)
+          "$.#{key.to_s.gsub("'", "''")}"
         end
 
         def format_time_value(value)

data/lib/trifle/stats/nocturnal.rb

@@ -87,9 +87,9 @@ module Trifle
           rescue ArgumentError
             # Handle edge cases like Feb 29 in non-leap years
             Time.new(
-              time.year + amount,
+              time.year + offset,
               time.month,
-              [time.day, days_in_month(time.year + amount, time.month)].min,
+              [time.day, days_in_month(time.year + offset, time.month)].min,
               time.hour,
               time.min,
               time.sec,