profitable 0.4.0 → 0.5.0

data/lib/profitable/processors/braintree_processor.rb

@@ -8,11 +8,13 @@ module Profitable
         amount = data['price']
         return 0 if amount.nil?
 
+        # Some processor payloads provide amounts as strings, so coerce before
+        # multiplying by quantity to avoid string repetition bugs.
         quantity = subscription.quantity || 1
         interval = data['billing_period_unit']
         interval_count = data['billing_period_frequency'] || 1
 
-        normalize_to_monthly(amount * quantity, interval, interval_count)
+        normalize_to_monthly(amount.to_f * quantity, interval, interval_count)
       end
     end
   end

data/lib/profitable/processors/paddle_billing_processor.rb

@@ -18,11 +18,12 @@ module Profitable
           amount = price_data.dig('unit_price', 'amount')
           next if amount.nil?
 
+          # Paddle can also serialize amounts as strings; coerce before applying quantity.
           item_quantity = item['quantity'] || 1
           interval = price_data.dig('billing_cycle', 'interval')
           interval_count = price_data.dig('billing_cycle', 'frequency')
 
-          total_mrr += normalize_to_monthly(amount * item_quantity, interval, interval_count)
+          total_mrr += normalize_to_monthly(amount.to_f * item_quantity, interval, interval_count)
         end
 
         total_mrr

data/lib/profitable/processors/paddle_classic_processor.rb

@@ -8,11 +8,12 @@ module Profitable
         amount = data['recurring_price']
         return 0 if amount.nil?
 
+        # Paddle Classic payloads may expose string amounts; coerce before quantity math.
         quantity = subscription.quantity || 1
         interval = data['recurring_interval']
         interval_count = 1 # Paddle Classic doesn't have interval_count
 
-        normalize_to_monthly(amount * quantity, interval, interval_count)
+        normalize_to_monthly(amount.to_f * quantity, interval, interval_count)
       end
     end
   end

data/lib/profitable/processors/stripe_processor.rb

@@ -18,6 +18,10 @@ module Profitable
           price_data = item['price'] || item
           next if price_data.nil?
 
+          # Metered items are usage-based, so they do not have a fixed run-rate that
+          # belongs in MRR/ARR style metrics. Keep only licensed recurring items here.
+          next if price_data.dig('recurring', 'usage_type') == 'metered'
+
           amount = price_data['unit_amount']
           next if amount.nil?
 

data/lib/profitable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profitable
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/profitable.rb

@@ -12,520 +12,4 @@ require "pay"
 require "active_support/core_ext/numeric/conversions"
 require "action_view"
 
-module Profitable
-  # Subscription status constants (at module level so MrrCalculator can reference them)
-  EXCLUDED_STATUSES = ['trialing', 'paused'].freeze
-  CHURNED_STATUSES  = ['canceled', 'ended'].freeze
-
-  class << self
-    include ActionView::Helpers::NumberHelper
-    include Profitable::JsonHelpers
-
-    DEFAULT_PERIOD = 30.days
-    MRR_MILESTONES = [5, 10, 20, 30, 50, 75, 100, 200, 300, 400, 500, 1_000, 2_000, 3_000, 5_000, 10_000, 20_000, 30_000, 50_000, 83_333, 100_000, 250_000, 500_000, 1_000_000, 5_000_000, 10_000_000, 25_000_000, 50_000_000, 75_000_000, 100_000_000]
-
-    def mrr
-      NumericResult.new(MrrCalculator.calculate)
-    end
-
-    def arr
-      NumericResult.new(calculate_arr)
-    end
-
-    def churn(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_churn(in_the_last), :percentage)
-    end
-
-    def all_time_revenue
-      NumericResult.new(calculate_all_time_revenue)
-    end
-
-    def revenue_in_period(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_revenue_in_period(in_the_last))
-    end
-
-    def recurring_revenue_in_period(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_recurring_revenue_in_period(in_the_last))
-    end
-
-    def recurring_revenue_percentage(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_recurring_revenue_percentage(in_the_last), :percentage)
-    end
-
-    def estimated_valuation(multiplier = nil, at: nil, multiple: nil)
-      actual_multiplier = multiplier || at || multiple || 3
-      NumericResult.new(calculate_estimated_valuation(actual_multiplier))
-    end
-
-    def total_customers
-      NumericResult.new(calculate_total_customers, :integer)
-    end
-
-    def total_subscribers
-      NumericResult.new(calculate_total_subscribers, :integer)
-    end
-
-    def active_subscribers
-      NumericResult.new(calculate_active_subscribers, :integer)
-    end
-
-    def new_customers(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_new_customers(in_the_last), :integer)
-    end
-
-    def new_subscribers(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_new_subscribers(in_the_last), :integer)
-    end
-
-    def churned_customers(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_churned_customers(in_the_last), :integer)
-    end
-
-    def new_mrr(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_new_mrr(in_the_last))
-    end
-
-    def churned_mrr(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_churned_mrr(in_the_last))
-    end
-
-    def average_revenue_per_customer
-      NumericResult.new(calculate_average_revenue_per_customer)
-    end
-
-    def lifetime_value
-      NumericResult.new(calculate_lifetime_value)
-    end
-
-    def mrr_growth(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_mrr_growth(in_the_last))
-    end
-
-    def mrr_growth_rate(in_the_last: DEFAULT_PERIOD)
-      NumericResult.new(calculate_mrr_growth_rate(in_the_last), :percentage)
-    end
-
-    def time_to_next_mrr_milestone
-      current_mrr = (mrr.to_i) / 100  # Convert cents to dollars
-      return "Unable to calculate. No MRR yet." if current_mrr <= 0
-
-      next_milestone = MRR_MILESTONES.find { |milestone| milestone > current_mrr }
-      return "Congratulations! You've reached the highest milestone." unless next_milestone
-
-      monthly_growth_rate = calculate_mrr_growth_rate / 100
-      return "Unable to calculate. Need more data or positive growth." if monthly_growth_rate <= 0
-
-      # Convert monthly growth rate to daily growth rate
-      daily_growth_rate = (1 + monthly_growth_rate) ** (1.0 / 30) - 1
-      return "Unable to calculate. Growth rate too small." if daily_growth_rate <= 0
-
-      # Calculate the number of days to reach the next milestone
-      days_to_milestone = (Math.log(next_milestone.to_f / current_mrr) / Math.log(1 + daily_growth_rate)).ceil
-
-      target_date = Time.current + days_to_milestone.days
-
-      "#{days_to_milestone} days left to $#{number_with_delimiter(next_milestone)} MRR (#{target_date.strftime('%b %d, %Y')})"
-    end
-
-    def monthly_summary(months: 12)
-      calculate_monthly_summary(months)
-    end
-
-    def daily_summary(days: 30)
-      calculate_daily_summary(days)
-    end
-
-    def period_data(in_the_last: DEFAULT_PERIOD)
-      calculate_period_data(in_the_last)
-    end
-
-    private
-
-    # Helper to load subscriptions with processor info from customer
-    def subscriptions_with_processor(scope = Pay::Subscription.all)
-      scope
-        .includes(:customer)
-        .select('pay_subscriptions.*, pay_customers.processor as customer_processor')
-        .joins(:customer)
-    end
-
-    def paid_charges
-      # Pay gem v10+ stores charge data in `object` column, older versions used `data`
-      # We check both columns for backwards compatibility using database-agnostic JSON extraction
-      #
-      # Performance note: The COALESCE pattern may prevent index usage on some databases.
-      # This is an acceptable tradeoff for backwards compatibility with Pay < 10.
-      # For high-volume scenarios, consider adding a composite index or upgrading to Pay 10+
-      # where only the `object` column is used.
-
-      # Build JSON extraction SQL for both object and data columns
-      paid_object = json_extract('pay_charges.object', 'paid')
-      paid_data = json_extract('pay_charges.data', 'paid')
-      status_object = json_extract('pay_charges.object', 'status')
-      status_data = json_extract('pay_charges.data', 'status')
-
-      Pay::Charge
-        .where("pay_charges.amount > 0")
-        .where(<<~SQL.squish, 'false', 'succeeded')
-          (
-            (COALESCE(#{paid_object}, #{paid_data}) IS NULL
-             OR COALESCE(#{paid_object}, #{paid_data}) != ?)
-          )
-          AND
-          (
-            COALESCE(#{status_object}, #{status_data}) = ?
-            OR COALESCE(#{status_object}, #{status_data}) IS NULL
-          )
-        SQL
-    end
-
-    def calculate_all_time_revenue
-      paid_charges.sum(:amount)
-    end
-
-    def calculate_arr
-      (mrr.to_f * 12).round
-    end
-
-    def calculate_estimated_valuation(multiplier = 3)
-      multiplier = parse_multiplier(multiplier)
-      (calculate_arr * multiplier).round
-    end
-
-    def parse_multiplier(input)
-      case input
-      when Numeric
-        input.to_f
-      when String
-        if input.end_with?('x')
-          input.chomp('x').to_f
-        else
-          input.to_f
-        end
-      else
-        3.0 # Default multiplier if input is invalid
-      end.clamp(0.1, 100) # Ensure multiplier is within a reasonable range
-    end
-
-    def calculate_churn(period = DEFAULT_PERIOD)
-      calculate_churn_rate_for_period(period.ago, Time.current)
-    end
-
-    def calculate_churned_customers(period = DEFAULT_PERIOD)
-      calculate_churned_subscribers_in_period(period.ago, Time.current)
-    end
-
-    def calculate_churned_mrr(period = DEFAULT_PERIOD)
-      calculate_churned_mrr_in_period(period.ago, Time.current)
-    end
-
-    def calculate_new_mrr(period = DEFAULT_PERIOD)
-      calculate_new_mrr_in_period(period.ago, Time.current)
-    end
-
-    def calculate_revenue_in_period(period)
-      paid_charges.where(created_at: period.ago..Time.current).sum(:amount)
-    end
-
-    def calculate_recurring_revenue_in_period(period)
-      paid_charges
-        .joins('INNER JOIN pay_subscriptions ON pay_charges.subscription_id = pay_subscriptions.id')
-        .where(created_at: period.ago..Time.current)
-        .sum(:amount)
-    end
-
-    def calculate_recurring_revenue_percentage(period)
-      total_revenue = calculate_revenue_in_period(period)
-      recurring_revenue = calculate_recurring_revenue_in_period(period)
-
-      return 0 if total_revenue.zero?
-
-      ((recurring_revenue.to_f / total_revenue) * 100).round(2)
-    end
-
-    def calculate_total_customers
-      Pay::Customer.joins(:charges)
-                   .merge(paid_charges)
-                   .distinct
-                   .count
-    end
-
-    def calculate_total_subscribers
-      Pay::Customer.joins(:subscriptions).distinct.count
-    end
-
-    def calculate_active_subscribers
-      Pay::Customer.joins(:subscriptions)
-                   .where(pay_subscriptions: { status: 'active' })
-                   .distinct
-                   .count
-    end
-
-    def actual_customers
-      Pay::Customer.joins("LEFT JOIN pay_subscriptions ON pay_customers.id = pay_subscriptions.customer_id")
-                   .joins("LEFT JOIN pay_charges ON pay_customers.id = pay_charges.customer_id")
-                   .where("pay_subscriptions.id IS NOT NULL OR pay_charges.amount > 0")
-                   .distinct
-    end
-
-    def calculate_new_customers(period)
-      actual_customers.where(created_at: period.ago..Time.current).count
-    end
-
-    def calculate_new_subscribers(period)
-      calculate_new_subscribers_in_period(period.ago, Time.current)
-    end
-
-    def calculate_average_revenue_per_customer
-      paying_customers = calculate_total_customers
-      return 0 if paying_customers.zero?
-      (all_time_revenue.to_f / paying_customers).round
-    end
-
-    def calculate_lifetime_value
-      # LTV = Monthly ARPU / Monthly Churn Rate
-      # where ARPU (Average Revenue Per User) = MRR / active subscribers
-      subscribers = calculate_active_subscribers
-      return 0 if subscribers.zero?
-
-      monthly_arpu = mrr.to_f / subscribers  # in cents
-      churn_rate = churn.to_f / 100  # monthly churn as decimal (e.g., 5% = 0.05)
-      return 0 if churn_rate.zero?
-
-      (monthly_arpu / churn_rate).round  # LTV in cents
-    end
-
-    def calculate_mrr_growth(period = DEFAULT_PERIOD)
-      new_mrr = calculate_new_mrr(period)
-      churned_mrr = calculate_churned_mrr(period)
-      new_mrr - churned_mrr
-    end
-
-    def calculate_mrr_growth_rate(period = DEFAULT_PERIOD)
-      end_date = Time.current
-      start_date = end_date - period
-
-      start_mrr = calculate_mrr_at(start_date)
-      end_mrr = calculate_mrr_at(end_date)
-
-      return 0 if start_mrr == 0
-      ((end_mrr.to_f - start_mrr) / start_mrr * 100).round(2)
-    end
-
-    def calculate_mrr_at(date)
-      # Find subscriptions that were active AT the given date:
-      # - Created before or on that date
-      # - Not ended before that date (ends_at is nil OR ends_at > date)
-      # - Not paused at that date
-      # - Not in trialing status (trials don't count as MRR)
-      subscriptions_with_processor(
-        Pay::Subscription
-          .where('pay_subscriptions.created_at <= ?', date)
-          .where('pay_subscriptions.ends_at IS NULL OR pay_subscriptions.ends_at > ?', date)
-          .where('pay_subscriptions.pause_starts_at IS NULL OR pay_subscriptions.pause_starts_at > ?', date)
-          .where.not(status: EXCLUDED_STATUSES)
-      ).sum do |subscription|
-        MrrCalculator.process_subscription(subscription)
-      end
-    end
-
-    def calculate_period_data(period)
-      period_start = period.ago
-      period_end = Time.current
-
-      new_customers_count = actual_customers.where(created_at: period_start..period_end).count
-      churned_count = calculate_churned_subscribers_in_period(period_start, period_end)
-      new_mrr_val = calculate_new_mrr_in_period(period_start, period_end)
-      churned_mrr_val = calculate_churned_mrr_in_period(period_start, period_end)
-      revenue_val = paid_charges.where(created_at: period_start..period_end).sum(:amount)
-
-      # Churn rate (reuses churned_count)
-      total_at_start = Pay::Subscription
-        .where('pay_subscriptions.created_at < ?', period_start)
-        .where('pay_subscriptions.ends_at IS NULL OR pay_subscriptions.ends_at > ?', period_start)
-        .where.not(status: EXCLUDED_STATUSES)
-        .distinct
-        .count('customer_id')
-      churn_rate = total_at_start > 0 ? (churned_count.to_f / total_at_start * 100).round(1) : 0
-
-      {
-        new_customers: NumericResult.new(new_customers_count, :integer),
-        churned_customers: NumericResult.new(churned_count, :integer),
-        churn: NumericResult.new(churn_rate, :percentage),
-        new_mrr: NumericResult.new(new_mrr_val),
-        churned_mrr: NumericResult.new(churned_mrr_val),
-        mrr_growth: NumericResult.new(new_mrr_val - churned_mrr_val),
-        revenue: NumericResult.new(revenue_val)
-      }
-    end
-
-    # Batched: loads all data in 5 queries then groups by month in Ruby
-    def calculate_monthly_summary(months_count)
-      overall_start = (months_count - 1).months.ago.beginning_of_month
-      overall_end = Time.current.end_of_month
-
-      # Bulk load all data for the full range
-      new_sub_records = Pay::Subscription
-        .where(created_at: overall_start..overall_end)
-        .where.not(status: EXCLUDED_STATUSES)
-        .pluck(:customer_id, :created_at)
-
-      churned_sub_records = Pay::Subscription
-        .where(status: CHURNED_STATUSES)
-        .where(ends_at: overall_start..overall_end)
-        .pluck(:customer_id, :ends_at)
-
-      new_mrr_subs = subscriptions_with_processor(
-        Pay::Subscription
-          .where(status: 'active')
-          .where(created_at: overall_start..overall_end)
-      ).to_a
-
-      churned_mrr_subs = subscriptions_with_processor(
-        Pay::Subscription
-          .where(status: CHURNED_STATUSES)
-          .where(ends_at: overall_start..overall_end)
-      ).to_a
-
-      churn_base_records = Pay::Subscription
-        .where('pay_subscriptions.created_at < ?', overall_end)
-        .where('pay_subscriptions.ends_at IS NULL OR pay_subscriptions.ends_at > ?', overall_start)
-        .where.not(status: EXCLUDED_STATUSES)
-        .pluck(:customer_id, :created_at, :ends_at)
-
-      # Group by month in Ruby
-      summary = []
-      (months_count - 1).downto(0) do |months_ago|
-        month_start = months_ago.months.ago.beginning_of_month
-        month_end = month_start.end_of_month
-
-        new_count = new_sub_records
-          .select { |_, created_at| created_at >= month_start && created_at <= month_end }
-          .map(&:first).uniq.count
-
-        churned_count = churned_sub_records
-          .select { |_, ends_at| ends_at >= month_start && ends_at <= month_end }
-          .map(&:first).uniq.count
-
-        new_mrr_amount = new_mrr_subs
-          .select { |s| s.created_at >= month_start && s.created_at <= month_end }
-          .sum { |s| MrrCalculator.process_subscription(s) }
-
-        churned_mrr_amount = churned_mrr_subs
-          .select { |s| s.ends_at >= month_start && s.ends_at <= month_end }
-          .sum { |s| MrrCalculator.process_subscription(s) }
-
-        total_at_start = churn_base_records
-          .select { |_, created_at, ends_at| created_at < month_start && (ends_at.nil? || ends_at > month_start) }
-          .map(&:first).uniq.count
-
-        churn_rate = total_at_start > 0 ? (churned_count.to_f / total_at_start * 100).round(1) : 0
-
-        summary << {
-          month: month_start.strftime('%Y-%m'),
-          month_date: month_start,
-          new_subscribers: new_count,
-          churned_subscribers: churned_count,
-          net_subscribers: new_count - churned_count,
-          new_mrr: new_mrr_amount,
-          churned_mrr: churned_mrr_amount,
-          net_mrr: new_mrr_amount - churned_mrr_amount,
-          churn_rate: churn_rate
-        }
-      end
-
-      summary
-    end
-
-    # Batched: loads all data in 2 queries then groups by day in Ruby
-    def calculate_daily_summary(days_count)
-      overall_start = (days_count - 1).days.ago.beginning_of_day
-      overall_end = Time.current.end_of_day
-
-      new_sub_records = Pay::Subscription
-        .where(created_at: overall_start..overall_end)
-        .where.not(status: EXCLUDED_STATUSES)
-        .pluck(:customer_id, :created_at)
-
-      churned_sub_records = Pay::Subscription
-        .where(status: CHURNED_STATUSES)
-        .where(ends_at: overall_start..overall_end)
-        .pluck(:customer_id, :ends_at)
-
-      summary = []
-      (days_count - 1).downto(0) do |days_ago|
-        day_start = days_ago.days.ago.beginning_of_day
-        day_end = day_start.end_of_day
-
-        new_count = new_sub_records
-          .select { |_, created_at| created_at >= day_start && created_at <= day_end }
-          .map(&:first).uniq.count
-
-        churned_count = churned_sub_records
-          .select { |_, ends_at| ends_at >= day_start && ends_at <= day_end }
-          .map(&:first).uniq.count
-
-        summary << {
-          date: day_start.to_date,
-          new_subscribers: new_count,
-          churned_subscribers: churned_count
-        }
-      end
-
-      summary
-    end
-
-    # Consolidated methods that work with any date range
-    def calculate_new_subscribers_in_period(period_start, period_end)
-      Pay::Customer.joins(:subscriptions)
-                   .where(pay_subscriptions: { created_at: period_start..period_end })
-                   .where.not(pay_subscriptions: { status: EXCLUDED_STATUSES })
-                   .distinct
-                   .count
-    end
-
-    def calculate_churned_subscribers_in_period(period_start, period_end)
-      Pay::Subscription
-        .where(status: CHURNED_STATUSES)
-        .where(ends_at: period_start..period_end)
-        .distinct
-        .count('customer_id')
-    end
-
-    def calculate_new_mrr_in_period(period_start, period_end)
-      subscriptions_with_processor(
-        Pay::Subscription
-          .where(status: 'active')
-          .where(created_at: period_start..period_end)
-      ).sum do |subscription|
-        MrrCalculator.process_subscription(subscription)
-      end
-    end
-
-    def calculate_churned_mrr_in_period(period_start, period_end)
-      subscriptions_with_processor(
-        Pay::Subscription
-          .where(status: CHURNED_STATUSES)
-          .where(ends_at: period_start..period_end)
-      ).sum do |subscription|
-        MrrCalculator.process_subscription(subscription)
-      end
-    end
-
-    def calculate_churn_rate_for_period(period_start, period_end)
-      # Count subscribers who were active AT the start of the period
-      total_subscribers_start = Pay::Subscription
-        .where('pay_subscriptions.created_at < ?', period_start)
-        .where('pay_subscriptions.ends_at IS NULL OR pay_subscriptions.ends_at > ?', period_start)
-        .where.not(status: EXCLUDED_STATUSES)
-        .distinct
-        .count('customer_id')
-
-      churned = calculate_churned_subscribers_in_period(period_start, period_end)
-      return 0 if total_subscribers_start == 0
-
-      (churned.to_f / total_subscribers_start * 100).round(1)
-    end
-
-  end
-end
+require_relative "profitable/metrics"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: profitable
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - rameerez
 bindir: exe
 cert_chain: []
-date: 2026-02-10 00:00:00.000000000 Z
+date: 2026-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pay
@@ -59,6 +59,7 @@ files:
 - app/views/layouts/profitable/application.html.erb
 - app/views/profitable/dashboard/index.html.erb
 - config/routes.rb
+- context7.json
 - gemfiles/pay_10.0.gemfile
 - gemfiles/pay_11.0.gemfile
 - gemfiles/pay_7.3.gemfile
@@ -70,6 +71,7 @@ files:
 - lib/profitable/engine.rb
 - lib/profitable/error.rb
 - lib/profitable/json_helpers.rb
+- lib/profitable/metrics.rb
 - lib/profitable/mrr_calculator.rb
 - lib/profitable/numeric_result.rb
 - lib/profitable/processors/base.rb