rails_local_analytics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 43724c92d8b23ef42ba4b5334f39f500d69075ea86e732ec405a3c5157200058
+  data.tar.gz: e1572a460c8bbee78956a431c55afdc208d2cbbc952562b6982a07cc2c24a9c3
+SHA512:
+  metadata.gz: ba528aae30b5ba1b5bdf814f78ca87d0b4d6bea70e15b2a5fc036a2ac9f27c529af5d59ea66595e15436edb025c71b10af308546fd38bf32155150175d158599
+  data.tar.gz: 11575f750a08aaafcf066fb9719209c3e5d3a8dd1447210bee1476786d5e48a88b3a070e350de04eaffcfee04fcfe1e56365483b6c28cc94f91d0a90e81ffe4e

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2024 Weston Ganger
+
+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,220 @@
+# Rails Local Analytics
+
+<a href="https://badge.fury.io/rb/rails_local_analytics" target="_blank"><img height="21" style='border:0px;height:21px;' border='0' src="https://badge.fury.io/rb/rails_local_analytics.svg" alt="Gem Version"></a>
+<a href='https://github.com/westonganger/rails_local_analytics/actions' target='_blank'><img src="https://github.com/westonganger/rails_local_analytics/actions/workflows/test.yml/badge.svg?branch=master" style="max-width:100%;" height='21' style='border:0px;height:21px;' border='0' alt="CI Status"></a>
+<a href='https://rubygems.org/gems/rails_local_analytics' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://img.shields.io/gem/dt/rails_local_analytics?color=brightgreen&label=Rubygems%20Downloads' border='0' alt='RubyGems Downloads' /></a>
+
+Simple, performant, local analytics for Rails. Solves 95% of your needs until your ready to start taking analytics more seriously using another tool.
+
+Out of the box the following request details are tracked:
+
+- day
+- total (count per day)
+- url_hostname (site)
+- url_path (page)
+- referrer_hostname
+- referrer_path
+- platform (ios, android, linux, osx, windows, etc)
+- [browser_engine](https://en.wikipedia.org/wiki/Comparison_of_browser_engines) (blink, gecko, webkit, or nil)
+
+It is fully customizable to store more details if desired.
+
+## Screenshots
+
+![Screenshot 1](/screenshot_1.png)
+
+![Screenshot 2](/screenshot_2.png)
+
+![Screenshot 3](/screenshot_3.png)
+
+## Installation
+
+```ruby
+# Gemfile
+gem "rails_local_analytics"
+```
+
+Add the following migration to your app:
+
+```
+bundle exec rails g migration CreateAnalyticsTables
+```
+
+```ruby
+# db/migrations/..._create_analytics_tables.rb
+
+class CreateAnalyticsTables < ActiveRecord::Migration[6.0]
+  def up
+    create_table :tracked_requests_by_day_page do |t|
+      t.date :day, null: false
+      t.bigint :total, null: false, default: 1
+      t.string :url_hostname, null: false
+      t.string :url_path, null: false
+      t.string :referrer_hostname
+      t.string :referrer_path
+    end
+    add_index :tracked_requests_by_day_page, :day
+
+    create_table :tracked_requests_by_day_site do |t|
+      t.date :day, null: false
+      t.bigint :total, null: false, default: 1
+      t.string :url_hostname, null: false
+      t.string :platform
+      t.string :browser_engine
+    end
+    add_index :tracked_requests_by_day_site, :day
+  end
+
+  def down
+    drop_table :tracked_requests_by_day_page
+    drop_table :tracked_requests_by_day_site
+  end
+end
+```
+
+Add the route for the analytics dashboard at the desired endpoint:
+
+```ruby
+# config/routes.rb
+mount RailsLocalAnalytics::Engine, at: "/admin/analytics"
+```
+
+Its generally recomended to use a background job (especially since we now have [`solid_queue`](https://github.com/rails/solid_queue/)). If you would like to disable background jobs you can use the following config:
+
+```ruby
+# config/initializers/rails_local_analytics.rb
+RailsLocalAnalytics.config.background_jobs = false # defaults to true
+```
+
+The next step is to collect traffic.
+
+## Recording requests
+
+There are two types of analytics that we mainly target:
+
+- Site level analytics
+  * Stored in the table `tracked_requests_by_day_site`
+- Page level analytics
+  * Stored in the table `tracked_requests_by_day_page`
+
+Your controllers have to manually call `RailsLocalAnalytics.record_request`. For example:
+
+```ruby
+class ApplicationController < ActionController::Base
+  after_action :record_page_view
+
+  private
+
+  def record_page_view
+    return if !request.format.html? && !request.format.json?
+
+    ### We accept manual overrides of any of the database fields
+    ### For example if you wanted to track bots:
+    site_based_attrs = {}
+    if some_custom_bot_detection_method
+      site_based_attrs[:platform] = "bot"
+    end
+
+    RailsLocalAnalytics.record_request(
+      request: request,
+      custom_attributes: { # optional
+        TrackedRequestsByDaySite.name => site_based_attrs,
+        #TrackedRequestsByDayPage.name => {},
+      },
+    )
+  end
+end
+```
+
+If you need to add more data to your events you can simply add more columns to the analytics tables and then populate these columns using the `:custom_attributes` argument.
+
+Some examples of additional things you may want to track:
+
+- Bot detection
+  * Bot detection is difficult. As such we dont try to include it by default. Recommended gem for detection is [`crawler_detect`](https://github.com/loadkpi/crawler_detect)
+  * One option is to consider not tracking bots at all in your analytics, just a thought
+  * You may not need to store this in a new column, one example pattern could be to store this data in the existing `platform` database field
+- Country detection
+  * Country detection is difficult. As such we dont try to include it by default.
+- Users or organizations
+  * You may want to track your users or another model which is a core tenant to your particular application
+
+
+## Performance Optimization Techniques
+
+There are a few techniques that you can use to tailor the database for your particular needs. Heres a few examples:
+
+- If you drop any database columns from the analytics tables this will not cause any issues. It will continue to function as normal.
+- `url_hostname` column
+  * If you wont ever have multi-site needs then you can consider removing this column
+  * If storage space is an issue you may consider switching to an enum column as the number of permutations is probably something that can be anticipated.
+- `referrer_host` and `referrer_path` columns
+  *  Consider just storing "local" or nil instead if the request originated from your website
+- `platform` and `browser_engine` columns
+  * Consider dropping either of these if you do not need this information
+
+## Usage where a request object is not available
+
+If you are not in a controller or do not have access to the request object then you may pass in a hash representation. For example:
+
+```ruby
+RailsLocalAnalytics.record_request(
+  request: {
+    host: "http://example.com",
+    path: "/some/path",
+    referrer: "http://example.com/some/other/path",
+    user_agent: "some-user-agent",
+    http_accept_language: "some-http-accept-language",
+  },
+  # ...
+)
+```
+
+## Deleting old data
+
+By default all data is retained indefinately. If you would like to have automated deletion of the data, you might use the following example technique:
+
+```ruby
+class ApplicationController
+  after_action :record_page_view
+
+  private
+
+  def record_page_view
+    # perform other logic and call RailsLocalAnalytics.record_request
+
+    TrackedRequestsByDayPage.where("date < ?", 3.months.ago).delete_all
+    TrackedRequestsByDaySite.where("date < ?", 3.months.ago).delete_all
+  end
+end
+```
+
+## Page Performance Tracking
+
+We dont do any page performance tracking (request/response time, etc), this gem only specializes in analytics.
+
+If you are looking for a simple performance tracking solution, I highly recommend the gem [`inner_performance`](https://github.com/mbajur/inner_performance)
+
+## Development
+
+Run server using: `bin/dev` or `cd test/dummy/; rails s`
+
+## Testing
+
+```
+bundle exec rspec
+```
+
+We can locally test different versions of Rails using `ENV['RAILS_VERSION']`
+
+```
+export RAILS_VERSION=7.0
+bundle install
+bundle exec rspec
+```
+
+## Credits
+
+Created & Maintained by [Weston Ganger](https://westonganger.com) - [@westonganger](https://github.com/westonganger)
+
+Imitated some parts of [`active_analytics`](https://github.com/BaseSecrete/active_analytics). Thanks to them for the aggregate database schema idea.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task test: [:spec]
+
+task default: [:spec]

data/app/assets/config/rails_local_analytics_manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images/rails_local_analytics
+//= link_directory ../stylesheets/rails_local_analytics .css
+//= link_directory ../javascripts/rails_local_analytics .js

data/app/assets/javascripts/rails_local_analytics/application.js

@@ -0,0 +1,7 @@
+$(function(){
+  $('table.table-sortable').tablesorter();
+
+  $(document).on("click", "tr[data-url]", function(){
+    window.location = $(this).data("url");
+  });
+});

data/app/assets/stylesheets/rails_local_analytics/application.css

@@ -0,0 +1,10 @@
+input, select {
+  border-radius: 5px;
+  border: 1px solid #333;
+  background: white;
+  padding: 2px 5px;
+}
+
+.tablesorter-header{
+  background-image: none !important;
+}

data/app/controllers/rails_local_analytics/application_controller.rb

@@ -0,0 +1,5 @@
+module RailsLocalAnalytics
+  class ApplicationController < ActionController::Base
+
+  end
+end

data/app/controllers/rails_local_analytics/dashboard_controller.rb

@@ -0,0 +1,61 @@
+module RailsLocalAnalytics
+  class DashboardController < ApplicationController
+
+    def index
+      params[:type] ||= "Site"
+
+      case params[:type]
+      when "Site"
+        @klass = TrackedRequestsByDaySite
+      when "Page"
+        @klass = TrackedRequestsByDayPage
+      else
+        raise ArgumentError
+      end
+
+      if params[:group_by].present? && !@klass.display_columns.include?(params[:group_by])
+        params[:group_by] = "All"
+      else
+        params[:group_by] ||= "All"
+      end
+
+      if params[:start_date].present?
+        @start_date = Date.parse(params[:start_date])
+      else
+        @start_date = Date.today
+      end
+
+      if params[:end_date]
+        @end_date = Date.parse(params[:end_date])
+      else
+        @end_date = Date.today
+      end
+
+      if @end_date < @start_date
+        @end_date = @start_date
+      end
+
+      @tracked_requests = fetch_records(@start_date, @end_date)
+
+      prev_start_date = @start_date - (@end_date - @start_date)
+      prev_end_date = @end_date - (@end_date - @start_date)
+
+      @prev_period_tracked_requests = fetch_records(prev_start_date, prev_end_date)
+    end
+
+    private
+
+    def fetch_records(start_date, end_date)
+      tracked_requests = @klass
+        .where("day >= ?", @start_date)
+        .where("day <= ?", @end_date)
+        .order(total: :desc)
+
+      if params[:search].present?
+        tracked_requests = tracked_requests.multi_search(params[:search])
+      end
+
+      return tracked_requests
+    end
+  end
+end

data/app/jobs/rails_local_analytics/application_job.rb

@@ -0,0 +1,5 @@
+module RailsLocalAnalytics
+  class ApplicationJob < ActiveJob::Base
+
+  end
+end

data/app/jobs/rails_local_analytics/record_request_job.rb

@@ -0,0 +1,122 @@
+module RailsLocalAnalytics
+  class RecordRequestJob < ApplicationJob
+    MODELS = [TrackedRequestsByDaySite, TrackedRequestsByDayPage].freeze
+    def perform(json)
+      if json.is_a?(String)
+        json = JSON.parse(json)
+      end
+
+      request_hash = json.fetch("request_hash")
+
+      custom_attributes_by_model = json.fetch("custom_attributes")
+
+      MODELS.each do |model|
+        custom_attrs = custom_attributes_by_model && custom_attributes_by_model[model.name]
+
+        attrs = build_attrs(model, custom_attrs, request_hash)
+
+        attrs["day"] = json.fetch("day")
+
+        existing_record = model.find_by(attrs)
+
+        if existing_record
+          existing_record.increment!(:total, 1)
+        else
+          model.create!(attrs)
+        end
+      end
+    end
+
+    private
+
+    def build_attrs(model, attrs, request_hash)
+      attrs ||= {}
+
+      field = "url_hostname"
+      if !skip_field?(field, attrs, model)
+        attrs[field] = request_hash.fetch("host").downcase
+      end
+
+      field = "url_path"
+      if !skip_field?(field, attrs, model)
+        attrs[field] = request_hash.fetch("path").downcase
+      end
+
+      if request_hash.fetch("referrer").present?
+        field = "referrer_hostname"
+        if !skip_field?(field,attrs, model)
+          referrer_hostname, referrer_path = split_referrer(request_hash.fetch("referrer"))
+          attrs[field] = referrer_hostname
+        end
+
+        field = "referrer_path"
+        if !skip_field?(field, attrs, model)
+          if referrer_path.nil?
+            referrer_hostname, referrer_path = split_referrer(request_hash.fetch("referrer"))
+          end
+          attrs[field] = referrer_path
+        end
+      end
+
+      if request_hash.fetch("user_agent").present?
+        field = "platform"
+        if !skip_field?(field, attrs, model)
+          browser ||= create_browser_object(request_hash)
+          attrs[field] = browser.platform.name
+        end
+
+        field = "browser_engine"
+        if !skip_field?(field, attrs, model)
+          browser ||= create_browser_object(request_hash)
+          attrs[field] = get_browser_engine(browser)
+        end
+      end
+
+      return attrs
+    end
+
+    def split_referrer(referrer)
+      referrer = referrer.downcase
+
+      uri = URI(referrer)
+
+      if uri.host.present?
+        return [
+          uri.host,
+          uri.path.presence,
+        ]
+      else
+        strings = referrer.split("/", 2)
+        return [
+          strings[0],
+          (strings[1].present? ? "/#{strings[1]}" : nil),
+        ]
+      end
+    end
+
+    def get_browser_engine(browser)
+      if browser.webkit?
+        # must come before all other checks because Firefox/Chrome on iOS devices is actually using Safari under the hood
+        "webkit"
+      elsif browser.chromium_based?
+        "blink"
+      elsif browser.firefox?
+        "gecko"
+      else
+        nil # store nothing, data is not useful
+      end
+    end
+
+    def create_browser_object(request_hash)
+      Browser.new(
+        request_hash.fetch("user_agent"),
+        accept_language: request_hash.fetch("http_accept_language"),
+      )
+    end
+
+    def skip_field?(field, attrs, model)
+      attrs&.has_key?(field) || !model.column_names.include?(field)
+    end
+
+  end
+end

data/app/lib/rails_local_analytics/histogram.rb

@@ -0,0 +1,47 @@
+module RailsLocalAnalytics
+  class Histogram
+    attr_reader :bars, :from_date, :to_date
+
+    def initialize(scope, from_date, to_date)
+      @scope = scope
+      @from_date, @to_date = from_date, to_date
+      @bars = scope.map { |record| Bar.new(record.date, record.total, self) }
+      fill_missing_days(@bars, @from_date, @to_date)
+    end
+
+    def fill_missing_days(bars, from, to)
+      i = 0
+      while (day = from + i) <= to
+        if !@bars[i] || @bars[i].label != day
+          @bars.insert(i, Bar.new(day, 0, self))
+        end
+        i += 1
+      end
+      @bars
+    end
+
+    def max_value
+      @max_total ||= bars.map(&:value).max
+    end
+
+    def total
+      @bars.reduce(0) { |sum, bar| sum += bar.value }
+    end
+
+    class Bar
+      attr_reader :label, :value, :histogram
+
+      def initialize(label, value, histogram)
+        @label, @value, @histogram = label, value, histogram
+      end
+
+      def height
+        if histogram.max_value > 0
+          (value.to_f / histogram.max_value).round(2)
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/app/models/rails_local_analytics/application_record.rb

@@ -0,0 +1,34 @@
+module RailsLocalAnalytics
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    scope :multi_search, ->(full_str){
+      if full_str.present?
+        relation = self
+
+        full_str.split(' ').each do |str|
+          like = connection.adapter_name.downcase.to_s == "postgres" ? "ILIKE" : "LIKE"
+
+          sql_conditions = []
+
+          display_columns.each do |col|
+            sql_conditions << "(#{col} #{like} :search)"
+          end
+
+          relation = self.where(sql_conditions.join(" OR "), search: "%#{str}%")
+        end
+
+        next relation
+      end
+    }
+
+    def self.display_columns
+      column_names - ["id", "created_at", "updated_at", "total", "day"]
+    end
+
+    def matches?(other_record)
+      day == other_record.day && self.class.display_columns.all?{|col_name| self.send(col_name) == other_record.send(col_name) }
+    end
+
+  end
+end

data/app/models/tracked_requests_by_day_page.rb

@@ -0,0 +1,8 @@
+class TrackedRequestsByDayPage < RailsLocalAnalytics::ApplicationRecord
+  self.table_name = "tracked_requests_by_day_page"
+
+  before_create do
+    self.total ||= 1
+  end
+
+end

data/app/models/tracked_requests_by_day_site.rb

@@ -0,0 +1,7 @@
+class TrackedRequestsByDaySite < RailsLocalAnalytics::ApplicationRecord
+  self.table_name = "tracked_requests_by_day_site"
+
+  before_create do
+    self.total ||= 1
+  end
+end

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

@@ -0,0 +1,33 @@
+<% title = RailsLocalAnalytics.name.titleize %>
+
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%= title %></title>
+    <meta name=viewport content="width=device-width, initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootswatch/3.4.0/cosmo/bootstrap.min.css" crossorigin="anonymous" referrerpolicy="no-referrer" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/jquery.tablesorter/2.32.0/css/theme.default.min.css" crossorigin="anonymous" referrerpolicy="no-referrer" />
+    <%= stylesheet_link_tag "rails_local_analytics/application" %>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery.tablesorter/2.31.0/js/jquery.tablesorter.min.js" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+    <%= javascript_include_tag "rails_local_analytics/application" %>
+  </head>
+
+  <body>
+    <nav class="navbar navbar-default">
+      <div class="container-fluid">
+        <div class="navbar-header">
+          <%= link_to title , root_path, class: "navbar-brand" %>
+        </h1>
+      </div>
+    </nav>
+
+    <div class="container-fluid">
+      <%= yield %>
+    </main>
+  </body>
+</html>

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

@@ -0,0 +1,101 @@
+<% page_group_by_options = options_for_select([["All", "All"]] + TrackedRequestsByDayPage.display_columns.map{|x| [x.titleize.sub("Url ", "URL "), x]}) %>
+<% site_group_by_options = options_for_select([["All", "All"]] + TrackedRequestsByDaySite.display_columns.map{|x| [x.titleize.sub("Url ", "URL "), x]}) %>
+
+<%= form_tag url_for(params.except(:start_date, :to).to_unsafe_hash), method: "get", class: "well well-sm" do %>
+  <div>
+    <label style="margin-right: 10px;">Type: <%= select_tag :type, options_for_select(["Site", "Page"], params[:type]) %></label>
+
+    <label style="margin-right: 10px;">Group By: <%= select_tag :group_by, options_for_select([["All", "All"]] + @klass.display_columns.map{|x| [x.titleize.sub("Url ", "URL "), x]} , params[:group_by]) %></label>
+    <label style="margin-right: 10px;">Search: <%= text_field_tag :search, params[:search] %></label>
+
+    <label style="margin-right: 10px;">From: <%= date_field_tag :start_date, @start_date %></label>
+    <label style="margin-right: 10px;">To: <%= date_field_tag :end_date, @end_date %></label>
+    <button type="submit">Filter</button>
+  </div>
+
+  <div>
+    <%= link_to "Today", url_for(params.merge(start_date: Date.today, end_date: Date.today).to_unsafe_hash) %>
+    |
+    <%= link_to "Yesterday", url_for(params.merge(start_date: (Date.today - 1.day), end_date: (Date.today - 1.day)).to_unsafe_hash) %>
+    |
+    <%= link_to "Last 7 days", url_for(params.merge(start_date: 7.days.ago.to_date, end_date: Date.today).to_unsafe_hash) %>
+    |
+    <%= link_to "Last 30 days", url_for(params.merge(start_date: 30.days.ago.to_date, end_date: Date.today).to_unsafe_hash) %>
+  </div>
+<% end %>
+
+<h2>Tracked Requests - <%= @klass.name.titleize.split(" ").last %></h2>
+
+<table class="table table-striped table-condensed table-sortable">
+  <thead>
+    <% if params[:group_by] == "All" %>
+      <% @klass.display_columns.each do |col_name| %>
+        <th>
+          <%= col_name.titleize.sub("Url ", "URL ") %>
+          <span title="Sort column">&varr;</span>
+        </th>
+      <% end %>
+    <% else %>
+      <td>
+        <%= params[:group_by].titleize.sub("Url ", "URL ") %>
+        <span title="Sort column">&varr;</span>
+      </td>
+    <% end %>
+
+    <th>
+      Total <span title="Difference compared to previous period">(Difference)</span>
+      <span title="Sort column">&varr;</span>
+    </th>
+  </thead>
+
+  <tbody>
+    <% @tracked_requests.group_by{|x| params[:group_by] != "All" ? x.send(params[:group_by]) : @klass.display_columns.map{|col| x.send(col)}}.each do |_grouping, records| %>
+      <% first_record = records.first %>
+
+      <tr>
+        <% if params[:group_by] == "All" %>
+          <% @klass.display_columns.each do |col_name| %>
+            <td>
+              <%= first_record.send(col_name) %>
+            </td>
+          <% end %>
+        <% else %>
+          <td>
+            <%= first_record.send(params[:group_by]) %>
+          </td>
+        <% end %>
+
+        <td>
+          <% total = records.sum(&:total) %>
+          <%= total %>
+
+          <% _grouping, prev_period_records = @prev_period_tracked_requests.select{|x| first_record.matches?(x) }.group_by{|x| params[:group_by] != "All" ? x.send(params[:group_by]) : @klass.display_columns.map{|col| x.send(col)}}.first %>
+          <% diff = total - prev_period_records.sum(&:total) %>
+
+          <% if diff >= 0 %>
+            (+<%= diff %>)
+          <% else %>
+            (<%= diff %>)
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<script>
+  $(function(){
+    var siteGroupByOptions = "<%= j site_group_by_options %>";
+    var pageGroupByOptions = "<%= j page_group_by_options %>";
+
+    $(document).on("change", "select[name='type']", function(){
+      var group_by_select = $("select[name='group_by']");
+
+      if($(this).val() == "Site"){
+        group_by_select.html(siteGroupByOptions);
+      }else{
+        group_by_select.html(pageGroupByOptions);
+      }
+    });
+  });
+</script>

data/config/routes.rb

@@ -0,0 +1,5 @@
+RailsLocalAnalytics::Engine.routes.draw do
+  get "/tracked_requests", to: "dashboard#index"
+
+  root to: "dashboard#index"
+end

data/lib/rails_local_analytics/engine.rb

@@ -0,0 +1,32 @@
+module RailsLocalAnalytics
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsLocalAnalytics
+
+    initializer "rails_local_analytics.assets.precompile" do |app|
+      # this initializer is only called when sprockets is in use
+
+      app.config.assets.precompile << "rails_local_analytics_manifest.js" ### manifest file required
+
+      ### Automatically precompile assets in specified folders
+      ["app/assets/images/"].each do |folder|
+        dir = app.root.join(folder)
+
+        if Dir.exist?(dir)
+          Dir.glob(File.join(dir, "**/*")).each do |f|
+            asset_name = f.to_s
+              .split(folder).last # Remove fullpath
+              .sub(/^\/*/, '') ### Remove leading '/'
+
+            app.config.assets.precompile << asset_name
+          end
+        end
+      end
+    end
+
+    initializer "rails_local_analytics.load_static_assets" do |app|
+      ### Expose static assets
+      app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+    end
+
+  end
+end

data/lib/rails_local_analytics/version.rb

@@ -0,0 +1,3 @@
+module RailsLocalAnalytics
+  VERSION = "0.1.0".freeze
+end

data/lib/rails_local_analytics.rb

@@ -0,0 +1,55 @@
+require "rails_local_analytics/version"
+require "rails_local_analytics/engine"
+require "browser/browser"
+
+module RailsLocalAnalytics
+
+  def self.record_request(request:, custom_attributes: nil)
+    if request.is_a?(Hash)
+      request_hash = request
+    else
+      ### Make request object generic so that it can be used outside of the controller
+
+      request_hash = {
+        referrer: request.referrer,
+        host: request.host,
+        path: request.path,
+        user_agent: request.user_agent,
+        http_accept_language: request.env["HTTP_ACCEPT_LANGUAGE"],
+      }
+    end
+
+    json_hash = {
+      day: Date.today.to_s,
+      request_hash: request_hash,
+      custom_attributes: custom_attributes,
+    }
+
+    if RailsLocalAnalytics.config.background_jobs
+      json_str = JSON.generate(json_hash) # convert to json string so that its compatible with all job backends
+      RecordRequestJob.perform_later(json_str)
+    else
+      RecordRequestJob.new.perform(json_hash)
+    end
+  end
+
+  def self.config(&block)
+    c = Config
+
+    if block_given?
+      block.call(c)
+    else
+      return c
+    end
+  end
+
+  class Config
+    @@background_jobs = true
+    mattr_reader :background_jobs
+
+    def self.background_jobs=(val)
+      @@background_jobs = !!val
+    end
+  end
+
+end

data/lib/tasks/rails_local_analytics_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rails_local_analytics do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: rails_local_analytics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Weston Ganger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails-controller-testing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple, performant, local analytics for Rails. Solves 95% of your needs
+  until your ready to start taking analytics more seriously using another tool.
+email:
+- weston@westonganger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/config/rails_local_analytics_manifest.js
+- app/assets/javascripts/rails_local_analytics/application.js
+- app/assets/stylesheets/rails_local_analytics/application.css
+- app/controllers/rails_local_analytics/application_controller.rb
+- app/controllers/rails_local_analytics/dashboard_controller.rb
+- app/jobs/rails_local_analytics/application_job.rb
+- app/jobs/rails_local_analytics/record_request_job.rb
+- app/lib/rails_local_analytics/histogram.rb
+- app/models/rails_local_analytics/application_record.rb
+- app/models/tracked_requests_by_day_page.rb
+- app/models/tracked_requests_by_day_site.rb
+- app/views/layouts/rails_local_analytics/application.html.erb
+- app/views/rails_local_analytics/dashboard/index.html.erb
+- config/routes.rb
+- lib/rails_local_analytics.rb
+- lib/rails_local_analytics/engine.rb
+- lib/rails_local_analytics/version.rb
+- lib/tasks/rails_local_analytics_tasks.rake
+homepage: https://github.com/westonganger/rails_local_analytics
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.22
+signing_key:
+specification_version: 4
+summary: Simple, performant, local analytics for Rails. Solves 95% of your needs until
+  your ready to start taking analytics more seriously using another tool.
+test_files: []