trifle-stats 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 053aa86693f158ba5a395ab80396f0b3274bff69481ec80dd4335e782d000bfe
-  data.tar.gz: 86be7c68e870d4fe38eac8dcae73634d8237a5334c8071c610932b22b57c735d
+  metadata.gz: 70c1c7a45dc8833c358ebab3d93a55e15f1f42f4459eb0d5fab14b7383de0a04
+  data.tar.gz: c09506de6ef9cd69b35733a616d43a09aa62ad8c6013f32552d1a0b7dcf870f6
 SHA512:
-  metadata.gz: cfc8e1a9b317808a37acc6799d87a99d856fe4e4f4b792ac223d96f4ac500b2e6c77e25a5e99e1861047524984cf7ce2bd691a6d930404384b973a173ed49e99
-  data.tar.gz: 383c36c748fa4266b2d741054f1f22a35baff5806ccb5ab169d3a0cf49c9fabad2fae97e64acb86fe2fbd534600acad0fe5ee6edac7a01faea6340c5b1eb1c13
+  metadata.gz: c980da761d8029b971ad9520d898d1971ba164c7cb2a1d7ffdbad60c67820cbb7eecf0ca25fa547518f06615dbe71411f376e20f2672dac1c9fca5c5dddaa5aa
+  data.tar.gz: 23266f716645654a5b642abf1558bbc85667b069dfb1caa98cfa1cc0899fd732769d2e0628107d06397b9b50996630b24a8f4ad6b634c5a8851d9984a66c7ad0

data/Gemfile.lock

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

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

@@ -60,32 +60,8 @@ module Trifle
         end
 
         def direct_write(operation:, key:, at:, values:, untracked: false)
-          body = gzip(JSON.generate(
-                        operation: operation.to_s,
-                        key: key,
-                        at: at.to_time.iso8601(6),
-                        values: values,
-                        untracked: untracked
-                      ))
-          request = Net::HTTP::Post.new(ENDPOINT)
-          request['Authorization'] = "Bearer #{token}"
-          request['X-Trifle-Source-Id'] = project_id
-          request['Content-Type'] = 'application/json'
-          request['Accept'] = 'application/json'
-          request['Content-Encoding'] = 'gzip'
-          request['User-Agent'] = "trifle-stats-ruby/#{Trifle::Stats::VERSION}"
-          request.body = body
-
-          response = @transport.call(uri: ENDPOINT, request: request, timeout: TIMEOUT)
-          return true if response.code.to_i.between?(200, 299)
-
-          response_body = response.body.to_s.byteslice(0, ERROR_BODY_LIMIT)
-          raise Error.new(
-            "Trifle API returned HTTP #{response.code}",
-            status: response.code.to_i,
-            response_body: response_body,
-            retry_after: response['Retry-After']
-          )
+          payload = api_payload(operation, key, at, values, untracked)
+          deliver(build_request(payload))
         rescue Error
           raise
         rescue StandardError => e
@@ -114,6 +90,49 @@ module Trifle
 
         private
 
+        def api_payload(operation, key, at, values, untracked)
+          {
+            operation: operation.to_s,
+            key: key,
+            at: at.to_time.iso8601(6),
+            values: values,
+            untracked: untracked
+          }
+        end
+
+        def build_request(payload)
+          request = Net::HTTP::Post.new(ENDPOINT, request_headers)
+          request.body = gzip(JSON.generate(payload))
+          request
+        end
+
+        def request_headers
+          {
+            'Authorization' => "Bearer #{token}",
+            'X-Trifle-Source-Id' => project_id,
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json',
+            'Content-Encoding' => 'gzip',
+            'User-Agent' => "trifle-stats-ruby/#{Trifle::Stats::VERSION}"
+          }
+        end
+
+        def deliver(request)
+          response = @transport.call(uri: ENDPOINT, request: request, timeout: TIMEOUT)
+          return true if response.code.to_i.between?(200, 299)
+
+          raise_response_error(response)
+        end
+
+        def raise_response_error(response)
+          raise Error.new(
+            "Trifle API returned HTTP #{response.code}",
+            status: response.code.to_i,
+            response_body: response.body.to_s.byteslice(0, ERROR_BODY_LIMIT),
+            retry_after: response['Retry-After']
+          )
+        end
+
         def gzip(value)
           output = StringIO.new
           Zlib::GzipWriter.wrap(output) { |writer| writer.write(value) }

data/lib/trifle/stats/nocturnal.rb

@@ -26,7 +26,8 @@ module Trifle
         item = from.dup
         while item <= to
           list << item
-          item = new(item, config: config).add(offset, unit)
+          candidate = new(item, config: config).add(offset, unit)
+          item = new(candidate, config: config).floor(offset, unit)
         end
         list
       end
@@ -49,53 +50,21 @@ module Trifle
 
         case unit
         when :second
-          time + offset
+          add_elapsed(offset)
         when :minute
-          time + (offset * 60)
+          add_elapsed(offset * 60)
         when :hour
-          time + (offset * 3600)
+          add_elapsed(offset * 3600)
         when :day
-          time + (offset * 86_400)
+          add_days(calendar_offset(offset))
         when :week
-          time + (offset * 604_800)
+          add_days(calendar_offset(offset) * 7)
         when :month
-          # Handle months carefully due to varying lengths
-          result = time
-          offset.times do
-            result = add_one_month(result)
-          end
-          result
+          add_months(calendar_offset(offset))
         when :quarter
-          # Add 3 months for each quarter
-          result = time
-          (offset * 3).times do
-            result = add_one_month(result)
-          end
-          result
+          add_months(calendar_offset(offset) * 3)
         when :year
-          # Handle years carefully due to leap years
-          begin
-            Time.new(
-              time.year + offset,
-              time.month,
-              time.day,
-              time.hour,
-              time.min,
-              time.sec,
-              config.tz.utc_offset
-            )
-          rescue ArgumentError
-            # Handle edge cases like Feb 29 in non-leap years
-            Time.new(
-              time.year + offset,
-              time.month,
-              [time.day, days_in_month(time.year + offset, time.month)].min,
-              time.hour,
-              time.min,
-              time.sec,
-              time.utc_offset
-            )
-          end
+          add_years(calendar_offset(offset))
         end
       end
 
@@ -104,89 +73,193 @@ module Trifle
         raise ArgumentError, 'Segment size must be positive' unless offset.positive?
         raise ArgumentError, "Invalid unit: #{unit}" unless Trifle::Stats::Nocturnal::UNIT_MAP.values.include?(unit)
 
+        source = localized_time
+
         case unit
         when :second
           # Floor to second segment boundary
-          total_seconds = time.sec
+          total_seconds = source.sec
           floored_seconds = (total_seconds / offset) * offset
-          Time.new(time.year, time.month, time.day, time.hour, time.min, floored_seconds, time.utc_offset)
+          subtract_elapsed(source, (total_seconds - floored_seconds) + source.subsec)
 
         when :minute
           # Floor to minute segment boundary (segments start from beginning of hour)
-          minutes_from_hour_start = time.min
+          minutes_from_hour_start = source.min
           floored_minutes = (minutes_from_hour_start / offset) * offset
-          Time.new(time.year, time.month, time.day, time.hour, floored_minutes, 0, time.utc_offset)
+          seconds = ((minutes_from_hour_start - floored_minutes) * 60) + source.sec + source.subsec
+          subtract_elapsed(source, seconds)
 
         when :hour
-          # Floor to hour segment boundary (segments start from beginning of day)
-          hours_from_day_start = time.hour
-          floored_hours = (hours_from_day_start / offset) * offset
-          Time.new(time.year, time.month, time.day, floored_hours, 0, 0, time.utc_offset)
+          # Hour segments are elapsed durations anchored at local day start.
+          day_start = local_midnight(source.to_date, source)
+          segment = offset * 3600
+          elapsed = source - day_start
+          add_elapsed_to(day_start, (elapsed / segment).floor * segment)
 
         when :day
           # Floor to day segment boundary (segments start from beginning of year)
-          days_from_year_start = time.yday - 1 # yday is 1-indexed, we want 0-indexed
+          days_from_year_start = source.yday - 1 # yday is 1-indexed, we want 0-indexed
           floored_days = (days_from_year_start / offset) * offset
-          year_start = Time.new(time.year, 1, 1, 0, 0, 0, time.utc_offset)
-          result_date = year_start.to_date + floored_days
-          Time.new(result_date.year, result_date.month, result_date.day, 0, 0, 0, time.utc_offset)
+          result_date = Date.new(source.year, 1, 1) + floored_days
+          local_midnight(result_date, source)
 
         when :week
           # Floor to week segment boundary (segments start from beginning of year)
-          year_start = Time.new(time.year, 1, 1, 0, 0, 0, time.utc_offset)
+          year_start_date = Date.new(source.year, 1, 1)
 
           # Find the first week boundary of the year based on week_start
-          week_start_offset = DAYS_INTO_WEEK.fetch(
-            config.beginning_of_week
-          )
-          year_start_wday = year_start.wday
+          week_start_offset = DAYS_INTO_WEEK.fetch(config.beginning_of_week)
+          year_start_wday = year_start_date.wday
           days_to_first_week_start = (week_start_offset - year_start_wday) % 7
-          first_week_start = year_start.to_date + days_to_first_week_start
-          first_week_start_time = Time.new(first_week_start.year, first_week_start.month, first_week_start.day, 0, 0, 0, time.utc_offset) # rubocop:disable Layout/LineLength
+          first_week_start = year_start_date + days_to_first_week_start
 
           # If current time is before first week boundary, use year start
-          if time < first_week_start_time
-            year_start
+          if source.to_date < first_week_start
+            local_midnight(year_start_date, source)
           else
-            # Calculate weeks since first week start
-            weeks_since_first = ((time - first_week_start_time) / (7 * 86_400)).to_i
+            weeks_since_first = ((source.to_date - first_week_start).to_i / 7)
             floored_weeks = (weeks_since_first / offset) * offset
 
             result_date = first_week_start + (floored_weeks * 7)
-            Time.new(result_date.year, result_date.month, result_date.day, 0, 0, 0, time.utc_offset)
+            local_midnight(result_date, source)
           end
 
         when :month
           # Floor to month segment boundary (from start of year)
-          months_from_jan = time.month - 1 # 0-indexed
+          months_from_jan = source.month - 1 # 0-indexed
           floored_months = (months_from_jan / offset) * offset
-          Time.new(time.year, floored_months + 1, 1, 0, 0, 0, time.utc_offset)
+          date = Date.new(source.year, floored_months + 1, 1)
+          local_midnight(date, source)
 
         when :quarter
           # Floor to quarter segment boundary
-          current_quarter = ((time.month - 1) / 3) # 0-indexed quarters
+          current_quarter = ((source.month - 1) / 3) # 0-indexed quarters
           floored_quarters = (current_quarter / offset) * offset
           quarter_start_month = (floored_quarters * 3) + 1
-          Time.new(time.year, quarter_start_month, 1, 0, 0, 0, time.utc_offset)
+          date = Date.new(source.year, quarter_start_month, 1)
+          local_midnight(date, source)
 
         when :year
           # Floor to year segment boundary
-          floored_years = (time.year / offset) * offset
-          Time.new(floored_years, 1, 1, 0, 0, 0, time.utc_offset)
+          floored_years = (source.year / offset) * offset
+          date = Date.new(floored_years, 1, 1)
+          local_midnight(date, source)
         end
       end
 
       private
 
-      def add_one_month(time) # rubocop:disable Metrics/AbcSize
-        next_month = time.month == 12 ? 1 : time.month + 1
-        next_year = time.month == 12 ? time.year + 1 : time.year
+      def add_elapsed(seconds)
+        add_elapsed_to(time, seconds)
+      end
+
+      def add_elapsed_to(source, seconds)
+        config.tz.utc_to_local((source + seconds).getutc)
+      end
+
+      def subtract_elapsed(source, seconds)
+        config.tz.utc_to_local((source - seconds).getutc)
+      end
+
+      def add_days(days)
+        source = localized_time
+        local_time_for_source(source.to_date + days, source)
+      end
+
+      def add_months(months)
+        source = localized_time
+        total_months = (source.year * 12) + (source.month - 1) + months
+        year, month_index = total_months.divmod(12)
+        month = month_index + 1
+        day = [source.day, days_in_month(year, month)].min
+
+        local_time_for_source(Date.new(year, month, day), source)
+      end
+
+      def add_years(years)
+        source = localized_time
+        year = source.year + years
+        day = [source.day, days_in_month(year, source.month)].min
+
+        local_time_for_source(Date.new(year, source.month, day), source)
+      end
+
+      def localized_time
+        config.tz.utc_to_local(time.getutc)
+      end
+
+      def calendar_offset(offset)
+        return offset if offset.is_a?(Integer)
+
+        raise ArgumentError, 'Offset must be an integer for calendar units'
+      end
+
+      def local_midnight(date, source)
+        local_time(date, source: source, hour: 0, minute: 0, second: 0)
+      end
+
+      def local_time_for_source(date, source)
+        local_time(
+          date,
+          source: source,
+          hour: source.hour,
+          minute: source.min,
+          second: source.sec,
+          sub_second: source.subsec
+        )
+      end
 
-        # Handle the case where the day doesn't exist in the next month (e.g., Jan 31 -> Feb 31)
-        max_day = days_in_month(next_year, next_month)
-        day = [time.day, max_day].min
+      def local_time(date, source:, **clock)
+        clock = { hour: 0, minute: 0, second: 0, sub_second: 0 }.merge(clock)
+        config.tz.local_time(
+          date.year, date.month, date.day,
+          clock[:hour], clock[:minute], clock[:second], clock[:sub_second], source.dst?
+        )
+      rescue TZInfo::AmbiguousTime
+        resolve_ambiguous_time(date, clock, source)
+      rescue TZInfo::PeriodNotFound
+        resolve_missing_time(date, clock, source)
+      end
+
+      def resolve_ambiguous_time(date, clock, source)
+        timestamp = local_timestamp(date, clock)
+        periods = config.tz.periods_for_local(timestamp)
+        period = periods.find { |candidate| candidate.observed_utc_offset == source.utc_offset } || periods.first
+        config.tz.utc_to_local(Time.at(timestamp.to_r - period.observed_utc_offset).utc)
+      end
+
+      def resolve_missing_time(date, clock, source)
+        timestamp = local_timestamp(date, clock)
+        transition = missing_time_transition(timestamp)
+        raise TZInfo::PeriodNotFound, timestamp.to_s unless transition
+
+        gap = transition.offset.observed_utc_offset - transition.previous_offset.observed_utc_offset
+        shifted = timestamp + gap
+        shifted_clock = { hour: shifted.hour, minute: shifted.min, second: shifted.sec, sub_second: shifted.subsec }
+        local_time(shifted.to_date, source: source, **shifted_clock)
+      end
+
+      def missing_time_transition(timestamp)
+        config.tz.transitions_up_to(timestamp + 172_800, timestamp - 172_800).find do |transition|
+          missing_time_transition?(timestamp, transition)
+        end
+      end
+
+      def missing_time_transition?(timestamp, transition)
+        previous_offset = transition.previous_offset.observed_utc_offset
+        next_offset = transition.offset.observed_utc_offset
+        return false unless next_offset > previous_offset
+
+        start_at = transition.at.to_time + previous_offset
+        end_at = transition.at.to_time + next_offset
+        timestamp >= start_at && timestamp < end_at
+      end
 
-        Time.new(next_year, next_month, day, time.hour, time.min, time.sec, config.tz.utc_offset)
+      def local_timestamp(date, clock)
+        Time.utc(
+          date.year, date.month, date.day,
+          clock[:hour], clock[:minute], clock[:second] + clock[:sub_second]
+        )
       end
 
       def days_in_month(year, month)

data/lib/trifle/stats/operations/timeseries/increment.rb

@@ -26,16 +26,30 @@ module Trifle
           end
 
           def perform
-            if config.driver.respond_to?(:direct_write)
-              return config.driver.direct_write(
-                operation: :track,
-                key: key,
-                at: @at,
-                values: values,
-                untracked: @untracked
-              )
-            end
+            return direct_write if direct_write?
+
+            buffered_write
+          end
+
+          def tracking_key
+            @untracked ? '__untracked__' : nil
+          end
+
+          private
+
+          def direct_write?
+            config.driver.respond_to?(:direct_write)
+          end
 
+          def direct_write
+            config.driver.direct_write(**direct_payload)
+          end
+
+          def direct_payload
+            { operation: :track, key: key, at: @at, values: values, untracked: @untracked }
+          end
+
+          def buffered_write
             payload = {
               keys: config.granularities.map { |granularity| key_for(granularity: granularity) },
               values: values
@@ -48,12 +62,6 @@ module Trifle
             end
           end
 
-          def tracking_key
-            @untracked ? '__untracked__' : nil
-          end
-
-          private
-
           def localized_time(time)
             base_time = time.is_a?(Time) ? time : time.to_time
             config.tz.utc_to_local(base_time.getutc)

data/lib/trifle/stats/operations/timeseries/set.rb

@@ -26,16 +26,30 @@ module Trifle
           end
 
           def perform
-            if config.driver.respond_to?(:direct_write)
-              return config.driver.direct_write(
-                operation: :assert,
-                key: key,
-                at: @at,
-                values: values,
-                untracked: @untracked
-              )
-            end
+            return direct_write if direct_write?
+
+            buffered_write
+          end
+
+          def tracking_key
+            @untracked ? '__untracked__' : nil
+          end
+
+          private
+
+          def direct_write?
+            config.driver.respond_to?(:direct_write)
+          end
 
+          def direct_write
+            config.driver.direct_write(**direct_payload)
+          end
+
+          def direct_payload
+            { operation: :assert, key: key, at: @at, values: values, untracked: @untracked }
+          end
+
+          def buffered_write
             payload = {
               keys: config.granularities.map { |granularity| key_for(granularity: granularity) },
               values: values
@@ -48,12 +62,6 @@ module Trifle
             end
           end
 
-          def tracking_key
-            @untracked ? '__untracked__' : nil
-          end
-
-          private
-
           def localized_time(time)
             base_time = time.is_a?(Time) ? time : time.to_time
             config.tz.utc_to_local(base_time.getutc)

data/lib/trifle/stats/version.rb

@@ -2,6 +2,6 @@
 
 module Trifle
   module Stats
-    VERSION = '2.6.0'
+    VERSION = '2.7.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trifle-stats
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Jozef Vaclavik
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler