skadi 0.4.0.beta.1 → 0.4.0.beta.2

data/app/controllers/skadi/tracking_controller.rb

@@ -14,7 +14,7 @@ module Skadi
 
     def track
       if @params["exit_page"].present? && @params["exit_page"].is_a?(String)
-        @view.exit_page = Skadi::Url.redact_and_normalise_url(@params["exit_page"])
+        @view.exit_page = Skadi::Url.redact_and_normalise_url(@params["exit_page"], request: request)
       end
 
       handle_consent @params["consent"]

data/app/models/skadi/dashboard.rb

@@ -22,15 +22,17 @@ module Skadi
             "title" => "Visits and Checkouts",
             "time_series" => "weekly",
 
-            "verified_visits" => true,
-            "unique_by" => "visit",
-            "visit_tracking" => "any",
-
             "datasets" => [
               {
                 "id" => "7cec5a7a-7bf7-403f-b15e-b2e45944182e",
-                "label" => "Visits",
-                "type" => "visits",
+                "label" => "Views",
+                "type" => "views",
+                "count_by" => "visitors",
+                "belongs_to" => {
+                  "visits" => { "filters" => [
+                    { "field" => "verified", "operator" => "=", "value" => true },
+                  ] },
+                },
               }.freeze,
             ].freeze,
           }.freeze,

data/app/models/skadi/dashboard_query.rb

@@ -110,11 +110,12 @@ module Skadi
       private def build_query_from_schema(dataset, chart, schema, untrusted_param_filters)
         query = schema[:model].all
 
+        query = apply_schema_associations(dataset, schema, query)
         query = apply_schema_filters(dataset, schema, query)
         query = apply_chart_filters(dataset, chart, schema, query, untrusted_param_filters)
 
         query = if chart["type"] == "table"
-          select_table_query(schema, query)
+          select_table_query(dataset, schema, query)
         else
           select_split_and_group_chart_query(dataset, chart, schema, query)
         end
@@ -122,6 +123,35 @@ module Skadi
         return query.to_sql
       end
 
+      private def dataset_each_belongs_to(dataset, schema)
+        return unless dataset["belongs_to"].is_a?(Hash)
+
+        dataset["belongs_to"].each do |belongs_to_table, belongs_to_config|
+          next unless belongs_to_config.is_a?(Hash)
+
+          # Ensure the schema for the current dataset allows joining to the given table
+          belongs_to_table = belongs_to_table.to_sym
+          next unless schema[:belongs_to]&.key?(belongs_to_table)
+
+          # Ensure the schema for the joined table exists
+          belongs_to_schema = Schema.database_schema[belongs_to_table]
+          next unless belongs_to_schema
+
+          yield(belongs_to_table, belongs_to_config, belongs_to_schema)
+        end
+      end
+
+      private def apply_schema_associations(dataset, schema, query)
+        dataset_each_belongs_to(dataset, schema) do |belongs_to_table, belongs_to_config, belongs_to_schema|
+          join_type = belongs_to_config["required"] ? "INNER JOIN" : "LEFT JOIN"
+          model = belongs_to_schema[:model]
+
+          query = query.joins(%(#{join_type} #{model.table_name} ON #{model.table_name}.id = #{schema[:model].table_name}.#{schema[:belongs_to][belongs_to_table][:key]}))
+        end
+
+        return query
+      end
+
       POSITIVE_OPERATORS = [ "=", ">", ">=", "<=", "<", "like" ].freeze
       NEGATED_OPERATORS = [ "!=", "not like" ].freeze
 
@@ -186,6 +216,11 @@ module Skadi
           end
         end
 
+        dataset_each_belongs_to(dataset, schema) do |_table, belongs_to_config, belongs_to_schema|
+          # Ensure nested belongs_to filters, which aren't supported, don't get applied
+          query = apply_schema_filters(belongs_to_config.except("belongs_to"), belongs_to_schema, query)
+        end
+
         return query
       end
 
@@ -202,42 +237,45 @@ module Skadi
           query = query.where("DATE(#{date_config[:sql]}) <= ?", date_to) unless date_to.nil?
         end
 
-        if schema[:visit_key]
-          # Join the visits if we need to
-          if chart["verified_visits"] == true || chart["visit_tracking"] || chart["unique_by"] == "visitor"
-            if schema[:model] != Skadi::Visit
-              query = query.joins(%(INNER JOIN skadi_visits ON skadi_visits.id = #{schema[:model].table_name}.#{schema[:visit_key]}))
-            end
-          end
+        return query
+      end
 
-          if chart["verified_visits"] == true
-            query = query.where("skadi_visits.verified = TRUE")
-          end
+      private def select_table_query(dataset, schema, query)
+        return query.select("'No fields selected' as error") unless dataset["selects"].nil? || dataset["selects"].is_a?(Array)
 
-          if chart["visit_tracking"] == "any"
-            query = query.where("skadi_visits.tracking_token IS NOT NULL")
-          elsif chart["visit_tracking"] == "anonymity_set"
-            query = query.where("skadi_visits.tracking_token IS NOT NULL AND skadi_visits.cookies_enabled = FALSE")
-          elsif chart["visit_tracking"] == "cookie"
-            query = query.where("skadi_visits.tracking_token IS NOT NULL AND skadi_visits.cookies_enabled = TRUE")
-          end
-        end
+        selects = dataset["selects"]&.any? ? dataset["selects"] : nil
 
-        return query
-      end
+        # Fall back to selecting all the fields
+        selects ||= schema[:fields].keys.map(&:to_s)
 
-      private def select_table_query(schema, query)
-        model = schema[:model]
-        select_fields = schema[:fields].map do |key, field_config|
-          quoted_field = model.connection.quote_column_name(key)
+        select_fields = selects.map do |field|
+          table, field = field.split(".", 2) if field.include?(".")
+          next unless table.nil? || (schema[:belongs_to]&.key?(table.to_sym) && dataset["belongs_to"].is_a?(Hash) && dataset["belongs_to"][table].is_a?(Hash))
+
+          field_schema = table.nil? ? schema : Schema.database_schema[table.to_sym]
+          next unless field_schema
+
+          field_config = field_schema[:fields][field.to_sym]
+
+          next unless field_config && field_config[:select]
+
+          quoted_field = field_schema[:model].connection.quote_column_name(field)
+          quoted_fieldname = if table.nil?
+            quoted_field
+          else
+            field_schema[:model].connection.quote_column_name("#{table}.#{field}")
+          end
 
           if field_config[:sql]
-            "#{field_config[:sql]} AS #{quoted_field}"
+            "#{field_config[:sql]} AS #{quoted_fieldname}"
           else
-            "#{model.table_name}.#{quoted_field}"
+            "#{field_schema[:model].table_name}.#{quoted_field} AS #{quoted_fieldname}"
           end
         end
 
+        select_fields.compact!
+        select_fields = [ "'No fields selected' as error" ] unless select_fields.any?
+
         return query.select(*select_fields)
       end
 
@@ -248,7 +286,7 @@ module Skadi
         safe_id = model.connection.quote(dataset["id"])
         safe_date = "NULL"
         safe_split = "NULL"
-        safe_count = "COUNT(*)"
+        safe_count = dataset_count(dataset, schema)
         safe_group = split_columns.dup
 
         if chart["time_series"].present? && schema[:fields][:date]
@@ -264,14 +302,6 @@ module Skadi
           safe_split = "CONCAT(#{split_columns.join(", '|~|', ")})"
         end
 
-        if schema[:count_sql]
-          safe_count = schema[:count_sql]
-        elsif chart["unique_by"] == "visit" && schema[:visit_key]
-          safe_count = "COUNT(DISTINCT #{schema[:model].table_name}.#{schema[:visit_key]})"
-        elsif chart["unique_by"] == "visitor" && schema[:visit_key]
-          safe_count = "COUNT(DISTINCT skadi_visits.tracking_token)"
-        end
-
         return query
             .select(
               "#{safe_id} AS id",
@@ -282,12 +312,38 @@ module Skadi
             .group(safe_group)
       end
 
+      private def dataset_count(dataset, schema)
+        # Fall back to the name of the current dataset if not set
+        count_by = dataset["count_by"].is_a?(String) ? dataset["count_by"].to_sym : dataset["type"].to_sym
+
+        # Match against the current schema's defined counts, allowing for overriding the default
+        return schema[:counts][count_by][:sql] if schema[:counts]&.[](count_by)
+
+        # Fallback to basic count if counting by the schema table
+        return "COUNT(*)" if count_by == dataset["type"].to_sym
+
+        # If the table is joined, then we can count by using the table's defined counts
+        dataset_each_belongs_to(dataset, schema) do |_table, _config, belongs_to_schema|
+          return belongs_to_schema[:counts][count_by][:sql] if belongs_to_schema[:counts]&.[](count_by)
+        end
+
+        # Fall back to counting by the foreign key
+        if schema[:belongs_to].is_a?(Hash)
+          schema[:belongs_to].each do |table, config|
+            return "COUNT(DISTINCT #{schema[:model].table_name}.#{config[:key]})" if table == count_by
+          end
+        end
+
+        # For invalid configs, we just fallback to a basic count
+        return "COUNT(*)"
+      end
+
       private def safe_split_columns(dataset, schema)
         safe_split = []
 
         if dataset["split_by"].is_a?(Array)
           dataset["split_by"].each do |field|
-            field_config = schema[:fields][field.to_sym]
+            field_config = schema[:fields][field.to_s.to_sym]
             if field_config && field_config[:split]
               safe_field = schema[:model].connection.quote_column_name(field)
 
@@ -296,6 +352,11 @@ module Skadi
           end
         end
 
+        # Now do the same thing for each belongs_to dataset
+        dataset_each_belongs_to(dataset, schema) do |_table, belongs_to_config, belongs_to_schema|
+          safe_split.append(*safe_split_columns(belongs_to_config.except("belongs_to"), belongs_to_schema))
+        end
+
         return safe_split
       end
 

data/app/models/skadi/dashboard_validator.rb

@@ -50,9 +50,6 @@ module Skadi
           time_series: OneOf.new(allowed_values: %w[daily weekly monthly].freeze, allow_missing: true).freeze,
           date_from: :date?,
           date_to: :date?,
-          verified_visits: :boolean?,
-          unique_by: OneOf.new(allowed_values: %w[visit visitor].freeze, allow_missing: true).freeze,
-          visit_tracking: OneOf.new(allowed_values: %w[any anonymity_set cookie].freeze, allow_missing: true).freeze,
           datasets: ArrayOf.new(:Dataset, 1),
         },
         percentageDataset: {
@@ -74,10 +71,12 @@ module Skadi
         dataset_type = COMMON_DATASET_FIELDS.dup
         dataset_type[:type] = dataset_name.to_s
 
+        select_fields = []
         split_by_fields = []
         filters = {}
 
         schema[:fields].each do |field, field_config|
+          select_fields << field.to_s if field_config[:select]
           split_by_fields << field.to_s if field_config[:split]
           next unless field_config[:filter]
 
@@ -88,12 +87,53 @@ module Skadi
           end
         end
 
+        schema[:belongs_to]&.keys&.each do |belongs_to_table|
+          Schema.database_schema[belongs_to_table][:fields].each do |field, field_config|
+           select_fields << "#{belongs_to_table}.#{field}" if field_config[:select]
+          end
+        end
+
+        dataset_type[:count_by] = OneOf.new(allowed_values: [
+          dataset_name.to_s,
+          # This may result in duplication if the default is overridden, but it will still function correctly
+          *schema[:counts]&.keys&.map(&:to_s),
+          *schema[:belongs_to]&.keys&.flat_map do |belongs_to_table|
+            [
+              belongs_to_table.to_s,
+              *Schema.database_schema[belongs_to_table][:counts]&.keys&.map(&:to_s),
+            ]
+          end,
+          nil,
+        ], allow_missing: true)
+
+        dataset_type[:selects] = ArrayOf.new(OneOf.new(select_fields, false)) if select_fields.any?
         dataset_type[:split_by] = ArrayOf.new(OneOf.new(split_by_fields, false)) if split_by_fields.any?
-        dataset_type[:filters] = ArrayOf.new(Filter.new(filters))
+        dataset_type[:filters] = ArrayOf.new(Filter.new(filters)) if filters.any?
 
         @types[:"#{dataset_name}Dataset"] = dataset_type
       end
 
+      # Second pass to add the validations for belongs_to fields
+      Schema.database_schema.each do |dataset_name, schema|
+        next unless schema[:belongs_to].is_a?(Hash) && schema[:belongs_to].any?
+
+        dataset_type = @types[:"#{dataset_name}Dataset"]
+
+        dataset_type[:belongs_to?] = {}
+        schema[:belongs_to].keys.each do |association|
+          target_table = @types[:"#{association}Dataset"]
+
+          # Double check that this association is actually in the schema
+          next unless target_table.is_a?(Hash)
+
+          association_type = { required: :boolean? }
+          association_type[:split_by] = target_table[:split_by] if target_table[:split_by]
+          association_type[:filters] = target_table[:filters] if target_table[:filters]
+
+          dataset_type[:belongs_to?][:"#{association}?"] = association_type
+        end
+      end
+
       return @types
     end
 
@@ -163,13 +203,21 @@ module Skadi
     private def validate_hash(type, value, path, context:)
       return add_error(path, "must be a hash", context:) unless value.is_a?(Hash)
 
-      extra_keys = value.keys.map(&:to_sym) - type.keys
+      valid_keys = type.keys.map do |key|
+        key.to_s.delete_suffix(??)
+      end
+
+      extra_keys = value.keys.map(&:to_s) - valid_keys
       extra_keys.each do |key|
         add_error("#{path}.#{key}", "is not a valid key", context:)
       end
 
       type.each do |item_key, item_type|
-        validate_type(item_type, value[item_key.to_s], "#{path}.#{item_key}", context:)
+        optional = item_key.end_with?(??)
+        key = item_key.to_s.delete_suffix(??)
+
+        next if optional && value[key].nil?
+        validate_type(item_type, value[key], "#{path}.#{key}", context:)
       end
     end
 
@@ -222,10 +270,44 @@ module Skadi
     private def validate_dataset(value, path, context:)
       return add_error(path, "must be a hash", context:) unless value.is_a?(Hash)
 
-      type = :"#{value["type"]}Dataset"
-      return add_error("#{path}.type", "is not a valid dataset type", context:) unless self.class.types.include?(type)
+      type_name = :"#{value["type"]}Dataset"
+      return add_error("#{path}.type", "is not a valid dataset type", context:) unless self.class.types.include?(type_name)
+
+      validate_type(self.class.types[type_name], value, path, context:)
+
+      # Perform additional validation of the select fields to ensure the right table is included
+
+      if value["selects"].is_a?(Array)
+        value["selects"].each_with_index do |field, index|
+          next unless field.is_a?(String) && field.include?(".")
+          table, _ = field.split(".", 2)
+
+          # Ensure that the relevant table is joined
+          if !value["belongs_to"]&.key?(table)
+            add_error("#{path}.selects[#{index}]", "#{field.inspect} requires a join with the #{table} table", context:)
+          end
+        end
+      end
+
+      # Perform additional validation of the count_by to ensure the right table is included
+      # Early return if the count is the default or is not a string
+      return if !value["count_by"].is_a?(String) || value["count_by"] == value["type"]
+
+      count_by = value["count_by"].to_sym
+
+      # Early return if the count is defined or is a foreign key on the current dataset
+      schema = Schema.database_schema[value["type"].to_sym]
+      return if schema[:counts]&.key?(count_by) || schema[:belongs_to]&.key?(count_by)
 
-      validate_type(type, value, path, context:)
+      # Find the table that has the given count as one of its counts
+      owner = schema[:belongs_to]&.keys&.find do |table|
+        Schema.database_schema[table][:counts]&.key?(count_by)
+      end
+
+      # Ensure that the relevant table is joined
+      if owner && !value["belongs_to"]&.key?(owner.to_s)
+        add_error("#{path}.count_by", "#{value["count_by"].inspect} requires a join with the #{owner} table", context:)
+      end
     end
 
     private def validate_custom_type(type, value, path, context:)

data/app/models/skadi/schema.rb

@@ -2,8 +2,8 @@ module Skadi
   class Schema
     class << self
       # Extract out the most common field config into a const
-      FILTER_AND_SPLIT = { filter: true, split: true }
-      private_constant :FILTER_AND_SPLIT
+      SELECT_FILTER_AND_SPLIT = { select: true, filter: true, split: true }
+      private_constant :SELECT_FILTER_AND_SPLIT
 
       # A hash where the key represents a dataset name and the value is its configuration
       def database_schema
@@ -12,99 +12,133 @@ module Skadi
         @_database_schema ||= {
           # A hash with the following keys:
           # model: The model for this dataset
-          # visit_key: used for chart-level visit filters
-          # count_sql: The SQL expression used to count this field. Defaults to COUNT().
+          # counts: A hash describing how this table can be counted, e.g. visitors: { sql: "COUNT(DISTINCT skadi_visits.tracking_token)" }
+          #         If the name of the count matches the table, the specified count overwrites the default of `COUNT(*)`
+          # belongs_to: A hash describing belongs_to relationships, e.g. {visits: {key: :visit_id}}
           # fields: A hash where the key represents a field and the value is its configuration
           visits: {
             model: Skadi::Visit,
-            visit_key: "id",
+            counts: {
+              visitors: { sql: "COUNT(DISTINCT skadi_visits.tracking_token)" },
+            },
             # If the table has a date field, the fields Hash expects a value for :date
             fields: {
               # A hash with the following keys:
               # label: The label to show in the front end
               # type: The datatype, one of :one_of, :date, :string, :number, :boolean. Defaults to :string.
+              # select: True if this field can be selected by the table chart
               # filter: True if this field can be filtered
               # split: True if this field can be split
               # sql: The SQL expression used to get this value for derived fields
               # options: A list of possible values
               # description: used in the front end as help text for this field
+              id: {
+                select: true,
+              },
               date: {
                 type: :date,
+                select: true,
                 filter: true,
                 sql: "skadi_visits.created_at",
               },
-              landing_page: FILTER_AND_SPLIT,
+              verified: {
+                **SELECT_FILTER_AND_SPLIT,
+                type: :boolean,
+              },
+              tracked: {
+                **SELECT_FILTER_AND_SPLIT,
+                type: :boolean,
+                sql: "(skadi_visits.tracking_token IS NOT NULL)",
+                description: "Whether the visit is tracked across multiple views and events using a cookie or anonymity set.",
+              },
+              cookies_enabled: {
+                **SELECT_FILTER_AND_SPLIT,
+                type: :boolean,
+                description: "Whether this visit is tracked across multiple days using cookies.",
+              },
+              landing_page: SELECT_FILTER_AND_SPLIT,
               referrer_domain: {
-                **FILTER_AND_SPLIT,
+                **SELECT_FILTER_AND_SPLIT,
                 sql: Helpers::Sql.string_before_separator(Skadi::Visit, "referrer", "/"),
               },
-              utm_source: FILTER_AND_SPLIT,
-              utm_medium: FILTER_AND_SPLIT,
-              utm_term: FILTER_AND_SPLIT,
-              utm_content: FILTER_AND_SPLIT,
-              utm_campaign: FILTER_AND_SPLIT,
+              utm_source: SELECT_FILTER_AND_SPLIT,
+              utm_medium: SELECT_FILTER_AND_SPLIT,
+              utm_term: SELECT_FILTER_AND_SPLIT,
+              utm_content: SELECT_FILTER_AND_SPLIT,
+              utm_campaign: SELECT_FILTER_AND_SPLIT,
             },
           },
           views: {
             model: Skadi::View,
-            visit_key: "visit_id",
+            belongs_to: { visits: { key: :visit_id } },
             fields: {
+              id: {
+                select: true,
+              },
               date: {
                 type: :date,
+                select: true,
                 filter: true,
                 sql: "skadi_views.created_at",
               },
               verified: {
+                **SELECT_FILTER_AND_SPLIT,
                 type: :boolean,
-                filter: true,
               },
-              controller: FILTER_AND_SPLIT,
+              controller: SELECT_FILTER_AND_SPLIT,
               action: {
+                select: true,
                 filter: true,
               },
               controller_and_action: {
                 split: true,
                 sql: "CONCAT(skadi_views.controller, '::', skadi_views.action)",
               },
-              path: FILTER_AND_SPLIT,
+              path: SELECT_FILTER_AND_SPLIT,
               verb: {
+                **SELECT_FILTER_AND_SPLIT,
                 type: :one_of,
-                filter: true,
-                split: true,
                 description: "Typically, GET requests are page views, and POST, PUT, PATCH and DELETE are form submissions.",
                 options: %w[GET POST PUT PATCH DELETE],
               },
-              version: FILTER_AND_SPLIT,
-              exit_page: FILTER_AND_SPLIT,
+              version: SELECT_FILTER_AND_SPLIT,
+              exit_page: SELECT_FILTER_AND_SPLIT,
             },
           },
           events: {
             model: Skadi::Event,
-            visit_key: "visit_id",
+            belongs_to: { visits: { key: :visit_id }, views: { key: :view_id } },
             fields: {
+              id: {
+                select: true,
+              },
               date: {
                 type: :date,
+                select: true,
                 filter: true,
                 sql: "skadi_events.created_at",
               },
-              name: FILTER_AND_SPLIT,
+              name: SELECT_FILTER_AND_SPLIT,
               **(Skadi.configuration.dashboard_custom_event_fields || {}),
             },
           },
           demographics: {
             model: Demographic,
-            count_sql: "COALESCE(SUM(skadi_demographics.count), 0)",
+            counts: {
+              demographics: { label: "Count", sql: "COALESCE(SUM(skadi_demographics.count), 0)" },
+            },
             fields: {
               date: {
                 type: :date,
+                select: true,
                 filter: true,
                 sql: "skadi_demographics.recorded_on",
               },
-              uri: FILTER_AND_SPLIT,
-              name: FILTER_AND_SPLIT,
-              value: FILTER_AND_SPLIT,
+              uri: SELECT_FILTER_AND_SPLIT,
+              name: SELECT_FILTER_AND_SPLIT,
+              value: SELECT_FILTER_AND_SPLIT,
               count: {
-                **FILTER_AND_SPLIT,
+                **SELECT_FILTER_AND_SPLIT,
                 type: :number,
               },
             },
@@ -113,19 +147,22 @@ module Skadi
         }
       end
 
+      ALLOWED_FRONTEND_DATASET_KEYS = [ :fields, :belongs_to, :counts ].freeze
+
       def frontend_schema
         return @_frontend_schema if defined?(@_frontend_schema)
 
         # Redact the SQL from the dashboard schema
         schema = database_schema.deep_dup
         schema.each_value do |dataset|
+          dataset[:belongs_to] = dataset[:belongs_to].keys if dataset.key?(:belongs_to)
+
           dataset.keys.each do |key|
-            dataset.delete(key) unless key == :fields
+            dataset.delete(key) unless ALLOWED_FRONTEND_DATASET_KEYS.include?(key)
           end
 
-          dataset[:fields].each_value do |field|
-            field.delete(:sql)
-          end
+          dataset[:counts]&.each_value { |field| field.delete(:sql) }
+          dataset[:fields].each_value { |field| field.delete(:sql) }
         end
 
         @_frontend_schema = schema

data/app/models/skadi/visit.rb

@@ -42,7 +42,7 @@ module Skadi
         tracking_token: tracking_token,
         user_id: user_id,
 
-        referrer: request ? Skadi::Url.redact_and_normalise_url(request.referrer) : nil,
+        referrer: request ? Skadi::Url.redact_and_normalise_url(request.referrer, request: request) : nil,
         landing_page: request ? Skadi::Url.view_path_from_request(request) : nil,
 
         utm_source: request ? request.query_parameters["utm_source"] : nil,

data/lib/skadi/configuration.rb

@@ -148,6 +148,7 @@ module Skadi
     #   {
     #     label: The label to show in the front end,
     #     type: The datatype, one of :date, :string, :number, :boolean. Defaults to :string if omitted.
+    #     select: `true` if this field can be selected by the table chart
     #     filter: `true` if this field can be filtered
     #     split: `true` if this field can be split
     #     sql: The SQL expression used to get this value for derived fields
@@ -163,8 +164,10 @@ module Skadi
       next true if it.nil?
       next false unless it.is_a?(Hash)
 
+      it.deep_symbolize_keys!
+
       next it.all? do |_key, item|
-        item.is_a?(Hash) && (item.keys.map(&:to_s) - %w[label type filter split sql option description]).empty?
+        item.is_a?(Hash) && (item.keys.map(&:to_s) - %w[label type select filter split sql options description]).empty?
       end
     end
 
@@ -177,6 +180,8 @@ module Skadi
         next false
       end
 
+      it.deep_symbolize_keys!
+
       tables_valid = it.all? do |_table_name, table_schema|
         unless table_schema.is_a?(Hash)
           error! "Skadi.configuration.dashboard_custom_schema values must be a hash"

data/lib/skadi/url.rb

@@ -33,8 +33,9 @@ module Skadi
 
     # Strips non-whitelisted query params and normalises URLs
     # @param url [String]
+    # @param request [ActionDispatch::Request, nil] the current request - used to truncate the current host from URLs
     # @return [String, nil]
-    def self.redact_and_normalise_url(url)
+    def self.redact_and_normalise_url(url, request: nil)
       return nil unless url.is_a?(String) && url.present?
 
       uri = URI.parse(url[0, Skadi.configuration.max_url_length])
@@ -45,16 +46,23 @@ module Skadi
 
       result = +""
 
+      interesting_scheme = uri.scheme.present? && ![ "http", "https" ].include?(uri.scheme)
       # Only record interesting schemes, e.g. "android-app://"
-      result += "#{uri.scheme}://" if uri.scheme.present? && ![ "http", "https" ].include?(uri.scheme)
+      result += "#{uri.scheme}://" if interesting_scheme
 
-      result += uri.host if uri.host.present?
+      host_with_port = +""
+      if uri.host.present?
+        host_with_port << uri.host
+        # Only include port if it's non-standard
+        host_with_port << ":#{uri.port}" if uri.port != uri.default_port
+      end
 
-      # Only include port if it's non-standard
-      result << ":#{uri.port}" if uri.port != uri.default_port
+      is_local = request.present? && host_with_port == request.host_with_port
+      result << host_with_port if interesting_scheme || Skadi.configuration.store_domain_in_views || !is_local
 
+      path = uri.path&.start_with?("/") ? uri.path : "/#{uri.path}"
       # Normalise the trailing slash
-      result << ((uri.path == "" || uri.path == "/") ? "/" : uri.path.chomp("/")) unless uri.path.nil?
+      result << (path == "/" ? "/" : path.delete_suffix("/"))
 
       result << (param_string.present? ? "?#{param_string}" : "")