profitable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f82abb3e6ad9cf2adc1c3bc0784458f78151171767d5435844506937432b06f1
+  data.tar.gz: c688c5cff7678cdbe18fce6d450040b49a4055329953ca2845dce01923ed396a
+SHA512:
+  metadata.gz: 209dd44cb7bbeeca27cd6cd738470bc2179e1cb748669e5c740b6e9d583fcb2a22f6e7af3af87c37b2b9c1967b05d30fe0076d3bf44bf2c791aa9299af94c1d4
+  data.tar.gz: e50c1a56b94f3da49bafa494dfc77a593ef82df75b7d26211e1c5860846a020897d187e006eba1d451a8694e1bd14eb0e951df66eee5c48d83828c9a60fe03f2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-08-29
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Javi R
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,166 @@
+# 💸 `profitable` - SaaS metrics for your Rails app
+
+[![Gem Version](https://badge.fury.io/rb/profitable.svg)](https://badge.fury.io/rb/profitable)
+
+Calculate the MRR, ARR, churn, LTV, ARPU, total revenue & estimated valuation of your `pay`-powered Rails SaaS app, and display them in a simple dashboard.
+
+![Profitable gem main dashboard](profitable.webp)
+
+## Why
+
+[`pay`](https://github.com/pay-rails/pay) is the easiest way of handling payments in your Rails application. Think of `profitable` as the complement to `pay` that calculates business SaaS metrics like MRR, ARR, churn, total revenue & estimated valuation directly within your Rails application.
+
+Usually, you would look into your Stripe Dashboard or query the Stripe API to know your MRR / ARR / churn – but when you're using `pay`, you already have that data available and auto synced to your own database. So we can leverage it to make handy, composable ActiveRecord queries that you can reuse in any part of your Rails app (dashboards, internal pages, reports, status messages, etc.)
+
+Think doing something like: `"Your app is currently at $#{Profitable.mrr} MRR – Estimated to be worth $#{Profitable.valuation_estimate("3x")} at a 3x valuation"`
+
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'profitable'
+```
+
+Then run `bundle install`.
+
+Provided you have a valid [`pay`](https://github.com/pay-rails/pay) installation (`Pay::Customer`, `Pay::Subscription`, `Pay::Charge`, etc.) everything is already set up and you can just start using [`Profitable` methods](#main-profitable-methods) right away.
+
+## Mount the `/profitable` dashboard
+
+`profitable` also provides a simple dashboard to see your main business metrics.
+
+In your `config/routes.rb` file, mount the `profitable` engine:
+```ruby
+mount Profitable::Engine => '/profitable'
+```
+
+It's a good idea to make sure you're adding some sort of authentication to the `/profitable` route to avoid exposing sensitive information:
+```ruby
+authenticate :user, ->(user) { user.admin? } do
+  mount Profitable::Engine => '/profitable'
+end
+```
+
+You can now navigate to `/profitable` to see your app's business metrics like MRR, ARR, churn, etc.
+
+## Main `Profitable` methods
+
+All methods return numbers that can be converted to a nicely-formatted, human-readable string using the `to_readable` method.
+
+### Revenue metrics
+
+- `Profitable.mrr`: Monthly Recurring Revenue (MRR)
+- `Profitable.arr`: Annual Recurring Revenue (ARR)
+- `Profitable.all_time_revenue`: Total revenue since launch
+- `Profitable.new_mrr(in_the_last: 30.days)`: New MRR added in the specified period
+- `Profitable.churned_mrr(in_the_last: 30.days)`: MRR lost due to churn in the specified period
+- `Profitable.average_revenue_per_customer`: Average revenue per customer (ARPC)
+- `Profitable.lifetime_value`: Estimated customer lifetime value (LTV)
+
+### Customer metrics
+
+- `Profitable.total_customers`: Total number of customers
+- `Profitable.total_subscribers`: Total number of active subscribers
+- `Profitable.new_customers(in_the_last: 30.days)`: Number of new customers (both subscribers and non-subscribers) added in the specified period
+- `Profitable.new_subscribers(in_the_last: 30.days)`: Number of new subscribers added in the specified period
+- `Profitable.churned_customers(in_the_last: 30.days)`: Number of customers who churned in the specified period
+
+### Other metrics
+
+- `Profitable.churn(in_the_last: 30.days)`: Churn rate as a percentage
+- `Profitable.estimated_valuation(multiplier = "3x")`: Estimated valuation based on ARR
+
+### Growth metrics
+
+- `Profitable.mrr_growth_rate(period: 30.days)`: Calculates the MRR growth rate over the specified period
+
+### Milestone metrics
+
+- `Profitable.time_to_next_mrr_milestone`: Estimates the time to reach the next MRR milestone
+
+### Usage examples
+
+```ruby
+# Get the current MRR
+Profitable.mrr.to_readable # => "$1,234"
+
+# Get the number of new customers in the last 60 days
+Profitable.new_customers(in_the_last: 60.days).to_readable # => "42"
+
+# Get the churn rate for the last quarter
+Profitable.churn(in_the_last: 3.months).to_readable # => "12%"
+
+# You can specify the precision of the output number (no decimals by default)
+Profitable.new_mrr(in_the_last: 24.hours).to_readable(2) # => "$123.45"
+
+# Get the estimated valuation at 5x ARR
+Profitable.estimated_valuation("5x").to_readable # => "$500,000"
+
+# Get the time to next MRR milestone
+Profitable.time_to_next_mrr_milestone.to_readable  # => "26 days left to $10,000 MRR"
+```
+
+All time-based methods default to a 30-day period if no time range is specified.
+
+### Numeric values and readable format
+
+Numeric values are returned in the same currency as your `pay` configuration. The `to_readable` method returns a human-readable format:
+
+- Currency values are prefixed with "$" and formatted as currency.
+- Percentage values are suffixed with "%" and formatted as percentages.
+- Integer values are formatted with thousands separators but without currency symbols.
+
+For more precise calculations, you can access the raw numeric value:
+```ruby
+# Returns the raw MRR integer value in cents (123456 equals $1.234,56)
+Profitable.mrr # => 123456
+```
+
+### Notes on specific metrics
+
+- `mrr_growth_rate`: This calculation compares the MRR at the start and end of the specified period. It assumes a linear growth rate over the period, which may not reflect short-term fluctuations. For more accurate results, consider using shorter periods or implementing a more sophisticated growth calculation method if needed.
+- `time_to_next_mrr_milestone`: This estimation is based on the current MRR and the recent growth rate. It assumes a constant growth rate, which may not reflect real-world conditions. The calculation may be inaccurate for very new businesses or those with irregular growth patterns.
+
+## Mount the `/profitable` dashboard
+
+We also provide a simple dashboard with good defaults to see your main business metrics.
+
+In your `config/routes.rb` file, mount the `profitable` engine:
+```ruby
+mount Profitable::Engine => '/profitable'
+```
+
+It's a good idea to make sure you're adding some sort of authentication to the `/profitable` route to avoid exposing sensitive information:
+```ruby
+authenticate :user, ->(user) { user.admin? } do
+  mount Profitable::Engine => '/profitable'
+end
+```
+
+You can now navigate to `/profitable` to see your app's business metrics like MRR, ARR, churn, etc.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## TODO
+- [ ] Add active customers (not just total customers)
+- [ ] Add revenue last month to dashboard
+- [ ] Add % of change over last period
+- [ ] Support other currencies other than USD
+- [ ] Support for multiple plans (churn by plan, MRR by plan, etc)
+- [ ] Make sure other payment processors other than Stripe work as intended
+- [ ] Account for subscription upgrades/downgrades within a period
+- [ ] Add a way to input monthly costs (maybe via config file?) so that we can calculate a profit margin %
+- [ ] Allow dashboard configuration via config file
+- [ ] Return a JSON in the dashboard endpoint with main metrics (for monitoring / downstream consumption)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rameerez/profitable. Our code of conduct is: just be nice and make your mom proud of what you do and post online.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/app/controllers/profitable/base_controller.rb

@@ -0,0 +1,5 @@
+module Profitable
+  class BaseController < ApplicationController
+    layout 'profitable/application'
+  end
+end

data/app/controllers/profitable/dashboard_controller.rb

@@ -0,0 +1,12 @@
+module Profitable
+  class DashboardController < BaseController
+    def index
+    end
+
+    private
+
+    def test
+    end
+
+  end
+end

data/app/views/layouts/profitable/application.html.erb

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>💸 <%= Rails.application.class.module_parent_name %> SaaS Dashboard</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  <link rel="stylesheet" href="https://cdn.simplecss.org/simple.min.css">
+</head>
+<body>
+  <%= yield %>
+</body>
+</html>

data/app/views/profitable/dashboard/index.html.erb

@@ -0,0 +1,106 @@
+<style>
+  .card-grid {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 16px; /* Adjusts the space between cards */
+    padding: 16px; /* Padding around the grid */
+  }
+
+  .card {
+    background-color: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--standard-border-radius);
+    padding: 16px;
+    flex: 1 1 calc(33.333% - 32px); /* 3 columns, with gap taken into account */
+    box-sizing: border-box;
+    text-align: center;
+  }
+
+  /* Make the grid responsive */
+  @media (max-width: 900px) {
+    .card {
+      flex: 1 1 calc(50% - 32px); /* 2 columns for tablets/smaller screens */
+    }
+  }
+
+  @media (max-width: 600px) {
+    .card {
+      flex: 1 1 100%; /* 1 column for mobile devices */
+    }
+  }
+</style>
+
+<header>
+  <h1>💸 <%= Rails.application.class.module_parent_name %></h1>
+  <% if Profitable.mrr_growth_rate > 0 %>
+    <p><%= Profitable.time_to_next_mrr_milestone %></p>
+  <% end %>
+</header>
+
+<main>
+
+  <div class="card-grid">
+    <div class="card">
+      <h2><%= Profitable.total_customers.to_readable %></h2>
+      <p>total customers</p>
+    </div>
+    <div class="card">
+      <h2><%= Profitable.mrr.to_readable %></h2>
+      <p>MRR</p>
+    </div>
+    <div class="card">
+      <h2><%= Profitable.estimated_valuation.to_readable %></h2>
+      <p>Valuation at 3x ARR</p>
+    </div>
+    <div class="card">
+      <h2><%= Profitable.mrr_growth_rate.to_readable %></h2>
+      <p>MRR growth rate</p>
+    </div>
+    <div class="card">
+      <h2><%= Profitable.average_revenue_per_customer.to_readable %></h2>
+      <p>ARPC</p>
+    </div>
+    <div class="card">
+      <h2><%= Profitable.lifetime_value.to_readable %></h2>
+      <p>LTV</p>
+    </div>
+    <div class="card">
+      <h2><%= Profitable.all_time_revenue.to_readable %></h2>
+      <p>All-time revenue</p>
+    </div>
+  </div>
+
+  <% [24.hours, 7.days, 30.days].each do |period| %>
+    <% period_short = period.inspect.gsub("days", "d").gsub("hours", "h").gsub(" ", "") %>
+
+    <h2>Last <%= period.inspect %></h2>
+
+    <div class="card-grid">
+      <div class="card">
+        <h2><%= Profitable.new_customers(in_the_last: period).to_readable %></h2>
+        <p>new customers (<%= period_short %>)</p>
+      </div>
+      <div class="card">
+        <h2><%= Profitable.churned_customers(in_the_last: period).to_readable %></h2>
+        <p>churned customers (<%= period_short %>)</p>
+      </div>
+      <div class="card">
+        <h2><%= Profitable.churn(in_the_last: period).to_readable %></h2>
+        <p>churn (<%= period_short %>)</p>
+      </div>
+      <div class="card">
+        <h2><%= Profitable.new_mrr(in_the_last: period).to_readable %></h2>
+        <p>new MRR (<%= period_short %>)</p>
+      </div>
+      <div class="card">
+        <h2><%= Profitable.churned_mrr(in_the_last: period).to_readable %></h2>
+        <p>churned MRR (<%= period_short %>)</p>
+      </div>
+    </div>
+  <% end %>
+
+</main>
+
+<footer>
+  <p>💸 <code>profitable</code> gem by <a href="https://rameerez.com">@rameerez</a></p>
+</footer>

data/config/routes.rb

@@ -0,0 +1,3 @@
+Profitable::Engine.routes.draw do
+  root to: "dashboard#index"
+end

data/lib/profitable/engine.rb

@@ -0,0 +1,15 @@
+module Profitable
+  class Engine < ::Rails::Engine
+    isolate_namespace Profitable
+
+    # TODO: implement config
+    # initializer "Profitable.load_configuration" do
+    #   config_file = Rails.root.join("config", "profitable.rb")
+    #   if File.exist?(config_file)
+    #     Profitable.configure do |config|
+    #       config.instance_eval(File.read(config_file))
+    #     end
+    #   end
+    # end
+  end
+end

data/lib/profitable/error.rb

@@ -0,0 +1,3 @@
+module Profitable
+  class Error < StandardError; end
+end

data/lib/profitable/mrr_calculator.rb

@@ -0,0 +1,55 @@
+require_relative 'processors/base'
+require_relative 'processors/stripe_processor'
+require_relative 'processors/braintree_processor'
+require_relative 'processors/paddle_billing_processor'
+require_relative 'processors/paddle_classic_processor'
+
+module Profitable
+  class MrrCalculator
+    def self.calculate
+      total_mrr = 0
+      subscriptions = Pay::Subscription
+        .active
+        .where.not(status: ['trialing', 'paused'])
+        .includes(:customer)
+        .select('pay_subscriptions.*, pay_customers.processor as customer_processor')
+        .joins(:customer)
+
+      subscriptions.find_each do |subscription|
+        mrr = process_subscription(subscription)
+        total_mrr += mrr
+      end
+
+      total_mrr
+    rescue => e
+      Rails.logger.error("Error calculating total MRR: #{e.message}")
+      raise Profitable::Error, "Failed to calculate MRR: #{e.message}"
+    end
+
+    def self.process_subscription(subscription)
+      return 0 if subscription.nil? || subscription.data.nil?
+
+      processor_class = processor_for(subscription.customer_processor)
+      processor_class.new(subscription).calculate_mrr
+    rescue => e
+      Rails.logger.error("Error calculating MRR for subscription #{subscription.id}: #{e.message}")
+      0
+    end
+
+    def self.processor_for(processor_name)
+      case processor_name
+      when 'stripe'
+        Processors::StripeProcessor
+      when 'braintree'
+        Processors::BraintreeProcessor
+      when 'paddle_billing'
+        Processors::PaddleBillingProcessor
+      when 'paddle_classic'
+        Processors::PaddleClassicProcessor
+      else
+        Rails.logger.warn("Unknown processor: #{processor_name}")
+        Processors::Base
+      end
+    end
+  end
+end

data/lib/profitable/numeric_result.rb

@@ -0,0 +1,43 @@
+module Profitable
+  class NumericResult < SimpleDelegator
+    include ActionView::Helpers::NumberHelper
+
+    def initialize(value, type = :currency)
+      super(value)
+      @type = type
+    end
+
+    def to_readable(precision = 0)
+      case @type
+      when :currency
+        "$#{price_in_cents_to_string(self, precision)}"
+      when :percentage
+        "#{number_with_precision(self, precision: precision)}%"
+      when :integer
+        number_with_delimiter(self)
+      when :string
+        self.to_s
+      else
+        to_s
+      end
+    end
+
+    private
+
+    def price_in_cents_to_string(price, precision = 2)
+      formatted_price = number_with_delimiter(
+        number_with_precision(
+          (price.to_f / 100), precision: precision
+        )
+      ).to_s
+
+      if price.zero?
+        "0"
+      elsif precision == 0
+        formatted_price
+      else
+        formatted_price.sub(/\.?0+$/, '')
+      end
+    end
+  end
+end

data/lib/profitable/processors/base.rb

@@ -0,0 +1,35 @@
+module Profitable
+  module Processors
+    class Base
+      attr_reader :subscription
+
+      def initialize(subscription)
+        @subscription = subscription
+      end
+
+      def calculate_mrr
+        0
+      end
+
+      protected
+
+      def normalize_to_monthly(amount, interval, interval_count)
+        return 0 if amount.nil? || interval.nil? || interval_count.nil?
+
+        case interval.to_s.downcase
+        when 'day'
+          amount * 30.0 / interval_count
+        when 'week'
+          amount * 4.0 / interval_count
+        when 'month'
+          amount / interval_count
+        when 'year'
+          amount / (12.0 * interval_count)
+        else
+          Rails.logger.warn("Unknown interval for MRR calculation: #{interval}")
+          0
+        end
+      end
+    end
+  end
+end

data/lib/profitable/processors/braintree_processor.rb

@@ -0,0 +1,14 @@
+module Profitable
+  module Processors
+    class BraintreeProcessor < Base
+      def calculate_mrr
+        amount = subscription.data['price']
+        quantity = subscription.quantity || 1
+        interval = subscription.data['billing_period_unit']
+        interval_count = subscription.data['billing_period_frequency'] || 1
+
+        normalize_to_monthly(amount * quantity, interval, interval_count)
+      end
+    end
+  end
+end

data/lib/profitable/processors/paddle_billing_processor.rb

@@ -0,0 +1,17 @@
+module Profitable
+  module Processors
+    class PaddleBillingProcessor < Base
+      def calculate_mrr
+        price_data = subscription.data['items']&.first&.dig('price')
+        return 0 if price_data.nil?
+
+        amount = price_data['unit_price']['amount']
+        quantity = subscription.quantity || 1
+        interval = price_data['billing_cycle']['interval']
+        interval_count = price_data['billing_cycle']['frequency']
+
+        normalize_to_monthly(amount * quantity, interval, interval_count)
+      end
+    end
+  end
+end

data/lib/profitable/processors/paddle_classic_processor.rb

@@ -0,0 +1,14 @@
+module Profitable
+  module Processors
+    class PaddleClassicProcessor < Base
+      def calculate_mrr
+        amount = subscription.data['recurring_price']
+        quantity = subscription.quantity || 1
+        interval = subscription.data['recurring_interval']
+        interval_count = 1 # Paddle Classic doesn't have interval_count
+
+        normalize_to_monthly(amount * quantity, interval, interval_count)
+      end
+    end
+  end
+end

data/lib/profitable/processors/stripe_processor.rb

@@ -0,0 +1,20 @@
+module Profitable
+  module Processors
+    class StripeProcessor < Base
+      def calculate_mrr
+        subscription_items = subscription.data['subscription_items']
+        return 0 if subscription_items.nil? || subscription_items.empty?
+
+        price_data = subscription_items[0]['price']
+        return 0 if price_data.nil?
+
+        amount = price_data['unit_amount']
+        quantity = subscription.quantity || 1
+        interval = price_data.dig('recurring', 'interval')
+        interval_count = price_data.dig('recurring', 'interval_count') || 1
+
+        normalize_to_monthly(amount * quantity, interval, interval_count)
+      end
+    end
+  end
+end

data/lib/profitable/version.rb

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

data/lib/profitable.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "profitable/version"
+require_relative "profitable/error"
+require_relative "profitable/engine"
+
+require_relative "profitable/mrr_calculator"
+require_relative "profitable/numeric_result"
+
+require "pay"
+require "active_support/core_ext/numeric/conversions"
+require "action_view"
+
+module Profitable
+  class << self
+    include ActionView::Helpers::NumberHelper
+
+    DEFAULT_PERIOD = 30.days
+    MRR_MILESTONES = [100, 1_000, 10_000, 100_000, 1_000_000, 10_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 estimated_valuation(multiplier = "3x")
+      NumericResult.new(calculate_estimated_valuation(multiplier))
+    end
+
+    def total_customers
+      NumericResult.new(Pay::Customer.count, :integer)
+    end
+
+    def total_subscribers
+      NumericResult.new(Pay::Subscription.active.distinct.count('customer_id'), :integer)
+    end
+
+    def new_customers(in_the_last: DEFAULT_PERIOD)
+      NumericResult.new(Pay::Customer.where(created_at: in_the_last.ago..Time.current).count, :integer)
+    end
+
+    def new_subscribers(in_the_last: DEFAULT_PERIOD)
+      NumericResult.new(
+        Pay::Subscription.active
+          .where(pay_subscriptions: { created_at: in_the_last.ago..Time.current })
+          .distinct.count('pay_customers.id'),
+        :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_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
+      next_milestone = MRR_MILESTONES.find { |milestone| milestone > current_mrr }
+      return "Congratulations! You've reached the highest milestone." unless next_milestone
+
+      growth_rate = calculate_mrr_growth_rate
+      return "Unable to calculate. Need more data or positive growth." if growth_rate <= 0
+
+      months_to_milestone = (Math.log(next_milestone.to_f / current_mrr) / Math.log(1 + growth_rate)).ceil
+      days_to_milestone = months_to_milestone * 30
+
+      return "#{days_to_milestone} days left to $#{number_with_delimiter(next_milestone)} MRR (#{(Time.current + days_to_milestone.days).strftime('%b %d, %Y')})"
+    end
+
+    private
+
+    def calculate_all_time_revenue
+      Pay::Charge.sum(:amount)
+    end
+
+    def calculate_arr
+      (mrr.to_f * 12).round
+    end
+
+    def calculate_estimated_valuation(multiplier = "3x")
+      multiplier = multiplier.to_s.gsub('x', '').to_f
+      (calculate_arr * multiplier).round
+    end
+
+    def calculate_churn(period = DEFAULT_PERIOD)
+      start_date = period.ago
+      total_subscribers_start = Pay::Subscription.active.where('created_at < ?', start_date).distinct.count('customer_id')
+      churned = calculate_churned_customers(period)
+      return 0 if total_subscribers_start == 0
+      (churned.to_f / total_subscribers_start * 100).round(2)
+    end
+
+    def churned_subscriptions(period = DEFAULT_PERIOD)
+      Pay::Subscription
+        .where(status: ['canceled', 'ended'])
+        .where(ends_at: period.ago..Time.current)
+    end
+
+    def calculate_churned_customers(period = DEFAULT_PERIOD)
+      churned_subscriptions(period).distinct.count('customer_id')
+    end
+
+    def calculate_churned_mrr(period = DEFAULT_PERIOD)
+      churned_subscriptions(period).sum do |subscription|
+        MrrCalculator.process_subscription(subscription)
+      end
+    end
+
+    def calculate_new_mrr(period = DEFAULT_PERIOD)
+      new_subscriptions = Pay::Subscription
+        .active
+        .where(pay_subscriptions: { created_at: period.ago..Time.current })
+        .where.not(status: ['trialing', 'paused'])
+        .includes(:customer)
+        .select('pay_subscriptions.*, pay_customers.processor as customer_processor')
+        .joins(:customer)
+
+      new_subscriptions.sum do |subscription|
+        MrrCalculator.process_subscription(subscription)
+      end
+    end
+
+    def calculate_average_revenue_per_customer
+      return 0 if total_customers.zero?
+      (all_time_revenue.to_f / total_customers).round
+    end
+
+    def calculate_lifetime_value
+      return 0 if total_customers.zero?
+      churn_rate = churn.to_f / 100
+      return 0 if churn_rate.zero?
+      (average_revenue_per_customer.to_f / churn_rate).round
+    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)
+      Pay::Subscription
+        .active
+        .where('pay_subscriptions.created_at <= ?', date)
+        .where.not(status: ['trialing', 'paused'])
+        .includes(:customer)
+        .select('pay_subscriptions.*, pay_customers.processor as customer_processor')
+        .joins(:customer)
+        .sum do |subscription|
+          MrrCalculator.process_subscription(subscription)
+        end
+    end
+  end
+end

data/sig/profitable.rbs

@@ -0,0 +1,4 @@
+module Profitable
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: profitable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- rameerez
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+description: Calculate SaaS metrics like the MRR, ARR, churn, LTV, ARPU, total revenue,
+  estimated valuation, and other business metrics of your `pay`-powered Rails app
+  – and display them in a simple dashboard.
+email:
+- rubygems@rameerez.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/controllers/profitable/base_controller.rb
+- app/controllers/profitable/dashboard_controller.rb
+- app/views/layouts/profitable/application.html.erb
+- app/views/profitable/dashboard/index.html.erb
+- config/routes.rb
+- lib/profitable.rb
+- lib/profitable/engine.rb
+- lib/profitable/error.rb
+- lib/profitable/mrr_calculator.rb
+- lib/profitable/numeric_result.rb
+- lib/profitable/processors/base.rb
+- lib/profitable/processors/braintree_processor.rb
+- lib/profitable/processors/paddle_billing_processor.rb
+- lib/profitable/processors/paddle_classic_processor.rb
+- lib/profitable/processors/stripe_processor.rb
+- lib/profitable/version.rb
+- profitable.webp
+- sig/profitable.rbs
+homepage: https://github.com/rameerez/profitable
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/rameerez/profitable
+  source_code_uri: https://github.com/rameerez/profitable
+  changelog_uri: https://github.com/rameerez/profitable
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.17
+signing_key:
+specification_version: 4
+summary: Calculate the MRR, ARR, churn, LTV, ARPU, total revenue & est. valuation
+  of your `pay`-powered Rails SaaS
+test_files: []