ahoy_analytics 0.1.0

data/app/models/ahoy/visit/ranges.rb

@@ -0,0 +1,227 @@
+module Ahoy::Visit::Ranges
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Build canonical ranges (no trimming) and clamp intervals, matching Plausible.
+    # Accepts optional query for date/from/to parameters.
+    def range_and_interval_for(period, requested_interval = nil, query = nil)
+      now = Time.zone.now
+
+      parse_date = lambda do |str|
+        begin
+          Time.zone.parse(str.to_s)
+        rescue ArgumentError
+          now
+        end
+      end
+
+      date_param = (query && query[:date]).presence
+      from_param = (query && query[:from]).presence
+      to_param   = (query && query[:to]).presence
+
+      case period
+      when "realtime"
+        range = (now - 30.minutes)..now
+        allowed = %w[minute]
+        default = "minute"
+
+      when "day"
+        d = date_param.present? ? parse_date.call(date_param) : now
+        range = d.beginning_of_day..d.end_of_day
+        allowed = %w[minute hour]
+        default = "hour"
+
+      when "7d"
+        end_date = (date_param.present? ? parse_date.call(date_param) : now).to_date - 1.day
+        start_date = end_date - 6.days
+        range = start_date.beginning_of_day..end_date.end_of_day
+        allowed = %w[hour day]
+        default = "day"
+
+      when "28d"
+        end_date = (date_param.present? ? parse_date.call(date_param) : now).to_date - 1.day
+        start_date = end_date - 27.days
+        range = start_date.beginning_of_day..end_date.end_of_day
+        allowed = %w[day week]
+        default = "day"
+
+      when "30d"
+        end_date = (date_param.present? ? parse_date.call(date_param) : now).to_date - 1.day
+        start_date = end_date - 29.days
+        range = start_date.beginning_of_day..end_date.end_of_day
+        allowed = %w[day week]
+        default = "day"
+
+      when "91d"
+        end_date = (date_param.present? ? parse_date.call(date_param) : now).to_date - 1.day
+        start_date = end_date - 90.days
+        range = start_date.beginning_of_day..end_date.end_of_day
+        allowed = %w[day week month]
+        default = "day"
+
+      when "month"
+        d = date_param.present? ? parse_date.call(date_param) : now
+        range = d.beginning_of_month..d.end_of_month
+        allowed = %w[day week]
+        default = "day"
+
+      when "6mo"
+        d = date_param.present? ? parse_date.call(date_param) : now
+        end_date = (d.to_date - 1.month).end_of_month
+        start_date = (end_date.to_date - 5.months).beginning_of_month
+        range = start_date.beginning_of_day..end_date.end_of_day
+        allowed = %w[day week month]
+        default = "month"
+
+      when "12mo"
+        d = date_param.present? ? parse_date.call(date_param) : now
+        end_date = (d.to_date - 1.month).end_of_month
+        start_date = (end_date.to_date - 11.months).beginning_of_month
+        range = start_date.beginning_of_day..end_date.end_of_day
+        allowed = %w[day week month]
+        default = "month"
+
+      when "year"
+        d = date_param.present? ? parse_date.call(date_param) : now
+        range = d.beginning_of_year..d.end_of_year
+        allowed = %w[day week month]
+        default = "month"
+
+      when "all"
+        starts = [ Ahoy::Visit.minimum(:started_at), Ahoy::Event.minimum(:time) ].compact
+        start_date = (starts.min || now).to_date
+        end_date = now.to_date
+        range = start_date.beginning_of_day..end_date.end_of_day
+        months = ((end_date.year * 12 + end_date.month) - (start_date.year * 12 + start_date.month)).abs
+        allowed = months > 12 ? %w[week month] : %w[day week month]
+        default = months > 0 ? "month" : "day"
+
+      when "custom"
+        if from_param.present? && to_param.present?
+          begin
+            from = parse_date.call(from_param).beginning_of_day
+            to   = parse_date.call(to_param).end_of_day
+            range = from..to
+          rescue ArgumentError
+            end_date = now.to_date - 1.day
+            start_date = end_date - 6.days
+            range = start_date.beginning_of_day..end_date.end_of_day
+          end
+        else
+          end_date = now.to_date - 1.day
+          start_date = end_date - 6.days
+          range = start_date.beginning_of_day..end_date.end_of_day
+        end
+
+      else
+        d = date_param.present? ? parse_date.call(date_param) : now
+        range = d.beginning_of_day..d.end_of_day
+        allowed = %w[minute hour]
+        default = "hour"
+      end
+
+      interval = requested_interval.to_s.presence
+      interval = default unless interval && allowed.include?(interval)
+      [ range, interval ]
+    end
+
+    # Trim to "now" for the main graph only (Plausible's include.trim_relative_date_range behavior)
+    def trim_range_to_now_if_applicable(range, period, comparison: nil)
+      return range unless %w[day month year].include?(period.to_s)
+      return range if comparison.present? && period.to_s == "day"
+
+      today = Time.zone.today
+      case period.to_s
+      when "day"
+        if range.begin.to_date == today && range.end.to_date == today
+          return range.begin..Time.zone.now
+        end
+      when "month"
+        month_start = today.beginning_of_month
+        month_end   = today.end_of_month
+        if range.begin.to_date == month_start && range.end.to_date == month_end
+          return range.begin..today.end_of_day
+        end
+      when "year"
+        year_start = Date.new(today.year, 1, 1)
+        year_end   = Date.new(today.year, 12, 31)
+        if range.begin.to_date == year_start && range.end.to_date == year_end
+          return range.begin..today.end_of_day
+        end
+      end
+      range
+    end
+
+    def previous_range(range)
+      from_date = range.begin.to_date
+      to_date   = range.end.to_date
+      days_span = (to_date - from_date).to_i + 1 # inclusive number of days in source
+      prev_from = (from_date - days_span).beginning_of_day
+      prev_to   = (to_date   - days_span).end_of_day
+      prev_from..prev_to
+    end
+
+    def year_over_year_range(range)
+      (range.begin - 1.year)..(range.end - 1.year)
+    end
+
+    def custom_compare_range(query)
+      cf = query[:compare_from]
+      ct = query[:compare_to]
+      return nil unless cf.present? && ct.present?
+      begin
+        from = Time.zone.parse(cf.to_s)
+        to = Time.zone.parse(ct.to_s)
+        from..to
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # When enabled, adjust the comparison range to start on the same weekday as the source range.
+    def align_comparison_weekday(comparison_range, source_range)
+      return comparison_range unless comparison_range && source_range
+      source_first = source_range.begin.to_date
+      comp_first   = comparison_range.begin.to_date
+
+      target_wday = source_first.wday # 0..6 (Sun..Sat)
+
+      return comparison_range if comp_first.wday == target_wday
+
+      next_occurring = begin
+        delta = (target_wday - comp_first.wday) % 7
+        delta = 7 if delta == 0
+        comp_first + delta
+      end
+
+      prev_occurring = begin
+        delta = (comp_first.wday - target_wday) % 7
+        delta = 7 if delta == 0
+        comp_first - delta
+      end
+
+      new_first_date = (next_occurring == source_first) ? prev_occurring : next_occurring
+      days_shifted = (new_first_date - comp_first).to_i
+      new_last_date = comparison_range.end.to_date + days_shifted
+
+      new_begin = Time.zone.parse(new_first_date.to_s).beginning_of_day
+      new_end   = Time.zone.parse(new_last_date.to_s).end_of_day
+      new_begin..new_end
+    end
+
+    # Build SQL for time bucketing in the app (site) timezone, then convert back to UTC.
+    def bucket_sql_for(column, interval)
+      zone = ActiveRecord::Base.connection.quote(Time.zone.tzinfo.name)
+      local = "((#{column} AT TIME ZONE 'UTC') AT TIME ZONE #{zone})"
+      truncated = case interval
+      when "month" then "date_trunc('month', #{local})"
+      when "week" then "date_trunc('week', #{local})"
+      when "day" then "date_trunc('day', #{local})"
+      when "hour" then "date_trunc('hour', #{local})"
+      when "minute" then "date_trunc('minute', #{local})"
+      else "date_trunc('hour', #{local})"
+      end
+      "(#{truncated} AT TIME ZONE #{zone})"
+    end
+  end
+end

data/app/models/ahoy/visit/series.rb

@@ -0,0 +1,177 @@
+module Ahoy::Visit::Series
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def main_graph_payload(query)
+      metric = (query[:metric] || "visitors").to_s
+      range, interval = Ahoy::Visit.range_and_interval_for(query[:period], query[:interval], query)
+      range = Ahoy::Visit.trim_range_to_now_if_applicable(range, query[:period], comparison: query[:comparison])
+      filters = query[:filters] || {}
+      advanced_filters = query[:advanced_filters] || []
+
+      series = series_for(range, interval, filters, metric, advanced_filters: advanced_filters)
+
+      comparison = nil
+      case query[:comparison]
+      when "previous_period"
+        prev_range = Ahoy::Visit.previous_range(range)
+        if ActiveModel::Type::Boolean.new.cast(query[:match_day_of_week])
+          prev_range = Ahoy::Visit.align_comparison_weekday(prev_range, range)
+        end
+        comparison = series_for(prev_range, interval, filters, metric, advanced_filters: advanced_filters)
+      when "year_over_year"
+        prev_range = Ahoy::Visit.year_over_year_range(range)
+        if ActiveModel::Type::Boolean.new.cast(query[:match_day_of_week])
+          prev_range = Ahoy::Visit.align_comparison_weekday(prev_range, range)
+        end
+        comparison = series_for(prev_range, interval, filters, metric, advanced_filters: advanced_filters)
+      when "custom"
+        prev_range = Ahoy::Visit.custom_compare_range(query)
+        comparison = prev_range ? series_for(prev_range, interval, filters, metric, advanced_filters: advanced_filters) : nil
+      end
+
+      full_intervals = case interval
+      when "week"
+        date_range = (range.begin.to_date..range.end.to_date)
+        series[:labels].each_with_object({}) do |label, acc|
+          begin
+            d = Date.parse(label)
+            start = d.beginning_of_week
+            finish = d.end_of_week
+            acc[label] = date_range.cover?(start) && date_range.cover?(finish)
+          rescue ArgumentError
+            acc[label] = false
+          end
+        end
+      when "month"
+        date_range = (range.begin.to_date..range.end.to_date)
+        series[:labels].each_with_object({}) do |label, acc|
+          begin
+            d = Date.parse(label)
+            start = d.beginning_of_month
+            finish = d.end_of_month
+            acc[label] = date_range.cover?(start) && date_range.cover?(finish)
+          rescue ArgumentError
+            acc[label] = false
+          end
+        end
+      else
+        nil
+      end
+
+      {
+        metric: metric,
+        plot: series[:values],
+        labels: series[:labels],
+        comparison_plot: comparison && comparison[:values],
+        comparison_labels: comparison && comparison[:labels],
+        present_index: series[:labels].length - 1,
+        interval: interval,
+        full_intervals: full_intervals
+      }
+    end
+
+    def series_for(range, interval, filters, metric, advanced_filters: [])
+      bucket_sql = Ahoy::Visit.bucket_sql_for("started_at", interval)
+      scope = Ahoy::Visit.scoped_visits(range, filters, advanced_filters: advanced_filters)
+
+      if %w[views_per_visit bounce_rate visit_duration].include?(metric.to_s)
+        map = calculate_complex_metric_series(range, interval, filters, metric.to_s, advanced_filters: advanced_filters)
+      else
+        grouped = case metric.to_s
+        when "visitors"
+          scope.group(Arel.sql(bucket_sql)).distinct.count(:visitor_token)
+        when "pageviews"
+          grouped_expression = Ahoy::Visit.bucket_sql_for("time", interval)
+          Ahoy::Visit.scoped_events(range, filters, advanced_filters: advanced_filters).group(Arel.sql(grouped_expression)).count
+        else # visits
+          scope.group(Arel.sql(bucket_sql)).count
+        end
+
+        map = grouped.each_with_object({}) do |(ts, v), h|
+          key = ts.is_a?(Time) ? ts.utc : ts.to_time.utc
+          h[key] = v.to_i
+        end
+      end
+
+      start_point = case interval
+      when "month" then range.begin.beginning_of_month
+      when "week" then range.begin.beginning_of_week
+      when "day" then range.begin.beginning_of_day
+      when "hour" then range.begin.beginning_of_hour
+      when "minute" then range.begin.beginning_of_minute
+      else range.begin.beginning_of_hour
+      end
+      step = case interval
+      when "month" then 1.month
+      when "week" then 1.week
+      when "day" then 1.day
+      when "hour" then 1.hour
+      when "minute" then 1.minute
+      else 1.hour
+      end
+      labels = []
+      values = []
+      t = start_point
+      while t <= range.end
+        key = t.utc
+        labels << key.iso8601
+        values << (map[key] || 0)
+        t += step
+      end
+
+      { values: values, labels: labels }
+    end
+
+    def calculate_complex_metric_series(range, interval, filters, metric, advanced_filters: [])
+      bucket_sql = Ahoy::Visit.bucket_sql_for("started_at", interval)
+      scope = Ahoy::Visit.scoped_visits(range, filters, advanced_filters: advanced_filters)
+      events_scope = Ahoy::Visit.scoped_events(range, filters, advanced_filters: advanced_filters)
+
+      visits_by_bucket = scope.group(Arel.sql(bucket_sql)).count
+      result = {}
+
+      visits_by_bucket.each do |bucket_time, _visit_count|
+        key = bucket_time.is_a?(Time) ? bucket_time.utc : bucket_time.to_time.utc
+        bucket_range = case interval
+        when "month" then key..(key + 1.month)
+        when "week" then key..(key + 1.week)
+        when "day" then key..(key + 1.day)
+        when "hour" then key..(key + 1.hour)
+        when "minute" then key..(key + 1.minute)
+        else key..(key + 1.hour)
+        end
+
+        bucket_visits = scope.where(started_at: bucket_range)
+        visit_ids = bucket_visits.pluck(:id)
+        next if visit_ids.empty?
+
+        case metric
+        when "views_per_visit"
+          pageviews_per_visit = events_scope.where(visit_id: visit_ids).group(:visit_id).count
+          pageviews = pageviews_per_visit.values.sum
+          v_with_events = pageviews_per_visit.size
+          result[key] = v_with_events > 0 ? (pageviews.to_f / v_with_events).round(2) : 0.0
+
+        when "bounce_rate"
+          pageviews_per_visit = events_scope.where(visit_id: visit_ids).group(:visit_id).count
+          v_with_events = pageviews_per_visit.size
+          bounces = pageviews_per_visit.count { |_, cnt| cnt == 1 }
+          result[key] = v_with_events > 0 ? ((bounces.to_f / v_with_events) * 100).round(2) : 0.0
+
+        when "visit_duration"
+          durations = events_scope
+            .where(visit_id: visit_ids)
+            .group(:visit_id)
+            .pluck(Arel.sql("visit_id, GREATEST(EXTRACT(EPOCH FROM (MAX(time) - MIN(time))), 0) as duration"))
+            .map { |_, duration| duration.to_f }
+
+          v_with_events = durations.size
+          result[key] = v_with_events > 0 ? (durations.sum / v_with_events).round(1) : 0.0
+        end
+      end
+
+      result
+    end
+  end
+end