trackguard 0.28.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2629b3c673c2ac2c1f4e338dedc3abc7f9b572fb57e9b4f9091139809e362bc
-  data.tar.gz: 6b4657343eecf9de2b48bea0df3f24c4463109dc6ae521dc83dad79741bbfe99
+  metadata.gz: 49c01824d558ae2b9416ed2451b7ecc9fd864a93979afb91ea1bdce297c198b2
+  data.tar.gz: 429ff2b09df7c9d9571ac7a863e3200a80b6ee4a50028284af0132d18b4b2b79
 SHA512:
-  metadata.gz: d8b5fc84be6801c276f5d7cb7dd0007a7b1c7d5d19d5db9858f2412396e3c99fc604e9276cc34ee0a05b4b63cc01f72fac8e176b1c2e852405813e0e484b4733
-  data.tar.gz: 96c791bce0d1cd72230e89e34a6335e4c7dfdbe818f90dccbd466bb3e908c2b9437e820dfe6afb9ced8a605e5293f341c65dd541e603a8bd9594210009c4dfe8
+  metadata.gz: 7da72f474a80e8b89b5549de51a3ebefa6cba99da4b9b1045b7d860b2628f10ac9950efcd7acdec94d438e1f72544e7c5189335285025c5c872a64b6e8d616ea
+  data.tar.gz: 7ce7519b8998ce10beab775c922e7c965cb017bfa4852a843173cbc586e0c8c3af95cf6df397a12b270869b6de04411c81c958fa53966f8185b75d47d5821a89

data/app/assets/stylesheets/trackguard/admin.css

@@ -240,6 +240,7 @@
 /* ── Table ─────────────────────────────────────────────────────────── */
 .tg-table {
   width: 100%;
+  table-layout: fixed;
   border-collapse: collapse;
   font-size: 0.875rem;
   margin-bottom: 2rem;
@@ -269,6 +270,14 @@
   text-align: right;
   color: #9ca3af;
   font-weight: 400;
+  white-space: nowrap;
+  width: 3.5rem;
+}
+
+.tg-td--label {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
 .tg-td--break { word-break: break-all; }

data/app/controllers/concerns/trackguard/page_tracker.rb

@@ -15,10 +15,11 @@ module Trackguard
     private
 
     def set_trace_id
-      @trace_id = SecureRandom.uuid
+      @trace_id = request.env["trackguard.trace_id"]
     end
 
     def track_page_view
+      return unless Trackguard.tracking_enabled?
       return unless request.get? || request.head?
       return unless request.format.html?
 
@@ -31,10 +32,17 @@ module Trackguard
         trace_id: @trace_id,
         source: extract_source,
         tracking_layer: "backend",
-        http_method: request.request_method
+        http_method: request.request_method,
+        prefetch: turbo_prefetch?
       )
     end
 
+    def turbo_prefetch?
+      request.headers["Purpose"] == "prefetch" ||
+        request.headers["Sec-Purpose"]&.start_with?("prefetch") ||
+        request.headers["X-Sec-Purpose"]&.start_with?("prefetch")
+    end
+
     def extract_source
       raw = params[:ref].presence || params[:utm_source].presence
       raw && raw.strip.downcase.first(64)

data/app/helpers/trackguard/application_helper.rb

@@ -1,10 +1,20 @@
 module Trackguard
   module ApplicationHelper
-    def trackguard_meta_tags
-      safe_join([
-                  tag.meta(name: "trackguard-url", content: trackguard.page_views_path),
-                  tag.meta(name: "trace-id", content: @trace_id)
-                ], "\n")
+    def trackguard_header_tags
+      return "".html_safe unless Trackguard.tracking_enabled?
+
+      tags = [ tag.meta(name: "trace-id", content: @trace_id) ]
+
+      case Trackguard.adapter
+      when Trackguard::Adapters::Local
+        tags << tag.meta(name: "trackguard-url", content: trackguard.page_views_path)
+      when Trackguard::Adapters::Hub
+        if Rails.env.production?
+          tags << tag.script(src: "#{Trackguard.hub_url}/track.js", data: { api_key: Trackguard.hub_api_key })
+        end
+      end
+
+      safe_join(tags, "\n")
     end
 
     def trackguard_nav_links

data/app/jobs/trackguard/detect_suspicious_visitors_job.rb

@@ -40,7 +40,7 @@ module Trackguard
     def analyze_visitor(visitor, views)
       count = views.size
       return if count.zero?
-      return if visitor.whitelisted_ip&.active?
+      return if whitelisted?(visitor)
 
       name = name_from_ua(visitor.user_agent)
 
@@ -183,6 +183,19 @@ module Trackguard
       )
     end
 
+    protected
+
+    def whitelisted?(visitor)
+      wl = visitor.whitelisted_ip
+      unless wl
+        wl = WhitelistedIp.active.find_by(ip: visitor.ip)
+        wl&.update!(visitor: visitor)
+      end
+      wl&.active?
+    end
+
+    private
+
     def name_from_ua(user_agent)
       BlockedUserAgent.matching_pattern(user_agent)
     end

data/app/jobs/trackguard/hub/submit_blocked_request_job.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Trackguard
+  module Hub
+    class SubmitBlockedRequestJob < ApplicationJob
+      queue_as :default
+
+      def perform(ip:, user_agent:, path:, http_method:, block_reason:)
+        uri  = URI("#{Trackguard.hub_url}/api/backend/blocked_requests")
+        body = {
+          blocked_request: {
+            ip: ip, user_agent: user_agent, path: path,
+            http_method: http_method, block_reason: block_reason
+          }
+        }.to_json
+
+        req                  = Net::HTTP::Post.new(uri)
+        req["X-Api-Key"]     = Trackguard.hub_api_key
+        req["Authorization"] = "Bearer #{Trackguard.hub_secret_key}"
+        req["Content-Type"]  = "application/json"
+        req.body             = body
+
+        opts     = { use_ssl: uri.scheme == "https", open_timeout: 3, read_timeout: 5 }
+        response = Net::HTTP.start(uri.hostname, uri.port, **opts) { |http| http.request(req) }
+
+        unless response.is_a?(Net::HTTPSuccess)
+          Rails.logger.warn(
+            "[Trackguard::Hub::SubmitBlockedRequestJob] Unexpected response #{response.code} for path=#{path}"
+          )
+        end
+      rescue StandardError => e
+        Rails.logger.warn("[Trackguard::Hub::SubmitBlockedRequestJob] Failed to submit blocked request: #{e.message}")
+      end
+    end
+  end
+end

data/app/jobs/trackguard/hub/submit_page_view_job.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Trackguard
+  module Hub
+    class SubmitPageViewJob < ApplicationJob
+      queue_as :default
+
+      def perform(path:, ip:, user_agent:, referer:, session_id:, trace_id:, source:, http_method:, **)
+        uri  = URI("#{Trackguard.hub_url}/api/backend/page_views")
+        body = {
+          page_view: {
+            path: path, referer: referer, session_id: session_id, trace_id: trace_id,
+            source: source, http_method: http_method, ip: ip, user_agent: user_agent
+          }
+        }.to_json
+
+        req                  = Net::HTTP::Post.new(uri)
+        req["X-Api-Key"]     = Trackguard.hub_api_key
+        req["Authorization"] = "Bearer #{Trackguard.hub_secret_key}"
+        req["Content-Type"]  = "application/json"
+        req.body             = body
+
+        opts     = { use_ssl: uri.scheme == "https", open_timeout: 3, read_timeout: 5 }
+        response = Net::HTTP.start(uri.hostname, uri.port, **opts) { |http| http.request(req) }
+
+        unless response.is_a?(Net::HTTPSuccess)
+          Rails.logger.warn(
+            "[Trackguard::Hub::SubmitPageViewJob] Unexpected response #{response.code} for path=#{path}"
+          )
+        end
+      rescue StandardError => e
+        Rails.logger.warn("[Trackguard::Hub::SubmitPageViewJob] Failed to submit page view: #{e.message}")
+      end
+    end
+  end
+end

data/app/jobs/trackguard/track_blocked_request_job.rb

@@ -5,20 +5,7 @@ module Trackguard
     queue_as :default
 
     def perform(ip:, user_agent:, path:, http_method:, block_reason:)
-      visitor = Visitor.find_or_create_by!(ip: ip) do |v|
-        v.user_agent    = user_agent
-        v.first_seen_at = Time.current
-        v.last_seen_at  = Time.current
-      end
-      visitor.update!(last_seen_at: Time.current, user_agent: user_agent)
-
-      BlockedRequest.create!(
-        path: path,
-        user_agent: user_agent,
-        http_method: http_method,
-        block_reason: block_reason,
-        visitor: visitor
-      )
+      TrackBlockedRequest.call(ip:, user_agent:, path:, http_method:, block_reason:)
     end
   end
 end

data/app/services/trackguard/track_blocked_request.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Trackguard
+  class TrackBlockedRequest < ApplicationService
+    def initialize(ip:, user_agent:, path:, http_method:, block_reason:, visitor_scope: {})
+      @ip           = ip
+      @user_agent   = user_agent
+      @path         = path
+      @http_method  = http_method
+      @block_reason = block_reason
+      @visitor_scope = visitor_scope
+    end
+
+    def call
+      visitor = Visitor.find_or_create_by!(ip: @ip, **@visitor_scope) do |v|
+        v.user_agent    = @user_agent
+        v.first_seen_at = Time.current
+        v.last_seen_at  = Time.current
+      end
+      visitor.update!(last_seen_at: Time.current, user_agent: @user_agent)
+
+      BlockedRequest.create!(
+        path: @path,
+        user_agent: @user_agent,
+        http_method: @http_method,
+        block_reason: @block_reason,
+        visitor: visitor,
+        **@visitor_scope
+      )
+    end
+  end
+end

data/app/views/trackguard/admin/_stats_panel.html.erb

@@ -15,7 +15,7 @@
       <tbody>
         <% rows.each do |label, count| %>
           <tr>
-            <td class="tg-td"><%= label %></td>
+            <td class="tg-td tg-td--label"><%= label %></td>
             <td class="tg-td tg-td--num"><%= count %></td>
           </tr>
         <% end %>

data/config/importmap.rb

@@ -1 +1,3 @@
-pin_all_from File.expand_path("../app/assets/javascripts/controllers", __dir__), under: "controllers"
+if Trackguard.adapter.is_a?(Trackguard::Adapters::Local)
+  pin_all_from File.expand_path("../app/assets/javascripts/controllers", __dir__), under: "controllers"
+end

data/config/routes.rb

@@ -1,4 +1,6 @@
 Trackguard::Engine.routes.draw do
+  next if Trackguard.adapter.is_a?(Trackguard::Adapters::Hub)
+
   post "/page_views", to: "page_views#create"
 
   scope "/admin", module: "admin" do

data/lib/trackguard/adapters/base.rb

@@ -3,13 +3,16 @@
 module Trackguard
   module Adapters
     class Base
+      def validate! = nil
+
       def blocked_user_agent?(user_agent) = raise NotImplementedError, "#{self.class}#blocked_user_agent?"
       def blocked_path?(path)             = raise NotImplementedError, "#{self.class}#blocked_path?"
       def whitelisted_ip?(ip)             = raise NotImplementedError, "#{self.class}#whitelisted_ip?"
       def flagged_visitor?(ip)            = raise NotImplementedError, "#{self.class}#flagged_visitor?"
 
       def track_page_view(path:, ip:, user_agent:, referer:, session_id:, trace_id:, source:, tracking_layer:,
-                          http_method:)
+                          http_method:, prefetch: false)
+        return unless Trackguard.tracking_enabled?
         return if blocked_user_agent?(user_agent)
         return if blocked_path?(path)
         return if path.blank? || path.start_with?(Trackguard.admin_path)
@@ -17,20 +20,27 @@ module Trackguard
         perform_track_page_view(
           path: path, ip: ip, user_agent: user_agent, referer: referer,
           session_id: session_id, trace_id: trace_id, source: source,
-          tracking_layer: tracking_layer, http_method: http_method
+          tracking_layer: tracking_layer, http_method: http_method, prefetch: prefetch
         )
       end
 
       def track_blocked_request(ip:, user_agent:, path:, http_method:, block_reason:)
-        raise NotImplementedError, "#{self.class}#track_blocked_request"
+        return unless Trackguard.tracking_enabled?
+
+        perform_track_blocked_request(ip: ip, user_agent: user_agent, path: path,
+                                      http_method: http_method, block_reason: block_reason)
       end
 
       protected
 
       def perform_track_page_view(path:, ip:, user_agent:, referer:, session_id:, trace_id:, source:,
-                                  tracking_layer:, http_method:)
+                                  tracking_layer:, http_method:, prefetch: false)
         raise NotImplementedError, "#{self.class}#perform_track_page_view"
       end
+
+      def perform_track_blocked_request(ip:, user_agent:, path:, http_method:, block_reason:)
+        raise NotImplementedError, "#{self.class}#perform_track_blocked_request"
+      end
     end
   end
 end

data/lib/trackguard/adapters/hub.rb

@@ -10,6 +10,33 @@ module Trackguard
       STALE_KEY = "trackguard/hub_rules/stale"
       ETAG_KEY  = "trackguard/hub_rules/etag"
 
+      def validate!
+        return unless Trackguard.tracking_enabled?
+
+        missing = []
+        missing << "hub_api_key"    if Trackguard.hub_api_key.blank?
+        missing << "hub_secret_key" if Trackguard.hub_secret_key.blank?
+        return if missing.empty?
+
+        raise Trackguard::ConfigurationError, <<~MSG.strip
+          Trackguard Hub adapter is missing required credentials: #{missing.join(', ')}.
+
+          Set them in your initializer:
+
+              Trackguard.configure do |c|
+                c.adapter        = :hub
+                c.hub_api_key    = ENV["TRACKGUARD_API_KEY"]
+                c.hub_secret_key = ENV["TRACKGUARD_SECRET_KEY"]
+              end
+
+          Sign up at https://trackguard.dev to create a project and generate credentials.
+
+          To use local tracking instead (no external service needed):
+
+              Trackguard.configure { |c| c.adapter = :local }
+        MSG
+      end
+
       def blocked_user_agent?(user_agent)
         rules.fetch(:blocked_user_agents, []).any? do |p|
           user_agent.to_s.downcase.include?(p.downcase)
@@ -30,15 +57,23 @@ module Trackguard
         rules.fetch(:flagged_ips, []).include?(ip)
       end
 
-      def track_blocked_request(ip:, user_agent:, path:, http_method:, block_reason:)
-        # placeholder: hub adapter does not persist blocked requests locally
-      end
-
       protected
 
+      def perform_track_blocked_request(ip:, user_agent:, path:, http_method:, block_reason:)
+        Trackguard::Hub::SubmitBlockedRequestJob.perform_later(
+          ip: ip, user_agent: user_agent, path: path, http_method: http_method, block_reason: block_reason
+        )
+      end
+
       def perform_track_page_view(path:, ip:, user_agent:, referer:, session_id:, trace_id:, source:,
-                                  tracking_layer:, http_method:)
-        # placeholder: hub tracking not yet implemented
+                                  tracking_layer:, http_method:, prefetch: false)
+        return if prefetch
+
+        Trackguard::Hub::SubmitPageViewJob.perform_later(
+          path: path, ip: ip, user_agent: user_agent, referer: referer,
+          session_id: session_id, trace_id: trace_id, source: source,
+          tracking_layer: tracking_layer, http_method: http_method
+        )
       end
 
       private
@@ -55,22 +90,8 @@ module Trackguard
       end
 
       def fetch_rules_from_hub
-        uri = URI("#{Trackguard.hub_url}/api/rules")
-        request = Net::HTTP::Get.new(uri)
-        request["Authorization"] = "Bearer #{Trackguard.hub_secret_key}"
-        request["Accept"] = "application/json"
-
-        etag = Rails.cache.read(ETAG_KEY)
-        request["If-None-Match"] = etag if etag
-
-        response = Net::HTTP.start(
-          uri.hostname, uri.port,
-          use_ssl: uri.scheme == "https",
-          open_timeout: 3,
-          read_timeout: 5
-        ) do |http|
-          http.request(request)
-        end
+        uri = URI("#{Trackguard.hub_url}/api/backend/rules")
+        response = execute_http(uri, build_request(uri))
 
         return Rails.cache.read(STALE_KEY) || {} if response.is_a?(Net::HTTPNotModified)
 
@@ -80,6 +101,21 @@ module Trackguard
         Rails.cache.write(ETAG_KEY, response["ETag"], expires_in: 24.hours) if response["ETag"]
         fresh
       end
+
+      def build_request(uri)
+        req = Net::HTTP::Get.new(uri)
+        req["Authorization"] = "Bearer #{Trackguard.hub_secret_key}"
+        req["X-Api-Key"] = Trackguard.hub_api_key
+        req["Accept"] = "application/json"
+        etag = Rails.cache.read(ETAG_KEY)
+        req["If-None-Match"] = etag if etag
+        req
+      end
+
+      def execute_http(uri, request)
+        opts = { use_ssl: uri.scheme == "https", open_timeout: 3, read_timeout: 5 }
+        Net::HTTP.start(uri.hostname, uri.port, **opts) { |http| http.request(request) }
+      end
     end
   end
 end

data/lib/trackguard/adapters/local.rb

@@ -19,7 +19,9 @@ module Trackguard
         Visitor.flagged?(ip)
       end
 
-      def track_blocked_request(ip:, user_agent:, path:, http_method:, block_reason:)
+      protected
+
+      def perform_track_blocked_request(ip:, user_agent:, path:, http_method:, block_reason:)
         TrackBlockedRequestJob.perform_later(
           ip: ip,
           user_agent: user_agent,
@@ -29,10 +31,8 @@ module Trackguard
         )
       end
 
-      protected
-
       def perform_track_page_view(path:, ip:, user_agent:, referer:, session_id:, trace_id:, source:,
-                                  tracking_layer:, http_method:)
+                                  tracking_layer:, http_method:, prefetch: false)
         TrackPageViewJob.perform_later(
           path: path,
           ip: ip,

data/lib/trackguard/engine.rb

@@ -6,7 +6,6 @@ module Trackguard
 
     config.to_prepare do
       ActionController::Base.helper Trackguard::ApplicationHelper
-      ActionController::Base.helper Trackguard::HubHelper
     end
 
     initializer "trackguard.assets" do |app|
@@ -17,7 +16,12 @@ module Trackguard
       app.config.importmap.paths << root.join("config/importmap.rb") if app.config.respond_to?(:importmap)
     end
 
+    initializer "trackguard.trace_id_middleware" do |app|
+      app.middleware.use Trackguard::TraceIdMiddleware
+    end
+
     config.after_initialize do
+      Trackguard.adapter.validate!
       Trackguard::RackAttack.configure
     end
   end

data/lib/trackguard/rack_attack.rb

@@ -4,28 +4,25 @@ require "rack/attack"
 
 module Trackguard
   module RackAttack
-    # rubocop:disable Metrics/MethodLength
     def self.configure
-      adapter = Trackguard.adapter
-
       ::Rack::Attack.safelist("trackguard/allow local") do |req|
         [ "127.0.0.1", "::1" ].include?(req.ip)
       end
 
       ::Rack::Attack.safelist("trackguard/allow whitelisted ips") do |req|
-        adapter.whitelisted_ip?(req.ip)
+        Trackguard.adapter.whitelisted_ip?(req.ip)
       end
 
       ::Rack::Attack.blocklist("trackguard/block known scanners") do |req|
-        adapter.blocked_user_agent?(req.user_agent)
+        Trackguard.adapter.blocked_user_agent?(req.user_agent)
       end
 
       ::Rack::Attack.blocklist("trackguard/block known paths") do |req|
-        adapter.blocked_path?(req.path)
+        Trackguard.adapter.blocked_path?(req.path)
       end
 
       ::Rack::Attack.blocklist("trackguard/flagged visitors") do |req|
-        adapter.flagged_visitor?(req.ip)
+        Trackguard.adapter.flagged_visitor?(req.ip)
       end
 
       ::Rack::Attack.throttle(
@@ -34,16 +31,15 @@ module Trackguard
         period: Trackguard.throttle_period, &:ip
       )
 
-      subscribe_to_blocked_requests(adapter)
+      subscribe_to_blocked_requests
     end
-    # rubocop:enable Metrics/MethodLength
 
-    def self.subscribe_to_blocked_requests(adapter)
+    def self.subscribe_to_blocked_requests
       @subscribe_to_blocked_requests ||= ActiveSupport::Notifications.subscribe("rack.attack") do |*, payload|
         req = payload[:request]
         next unless req.env["rack.attack.match_type"] == :blocklist
 
-        adapter.track_blocked_request(
+        Trackguard.adapter.track_blocked_request(
           ip: req.ip,
           user_agent: req.user_agent.to_s,
           path: req.path,

data/lib/trackguard/trace_id_middleware.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Trackguard
+  class TraceIdMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["trackguard.trace_id"] = SecureRandom.uuid
+      @app.call(env)
+    end
+  end
+end

data/lib/trackguard/version.rb

@@ -1,3 +1,3 @@
 module Trackguard
-  VERSION = "0.28.0".freeze
+  VERSION = "0.30.0".freeze
 end

data/lib/trackguard.rb

@@ -3,15 +3,90 @@
 require "trackguard/version"
 require "trackguard/engine"
 require "trackguard/rack_attack"
+require "trackguard/trace_id_middleware"
 require "trackguard/adapters/base"
 require "trackguard/adapters/local"
 require "trackguard/adapters/hub"
 
 module Trackguard
+  class ConfigurationError < StandardError; end
+
   class << self
-    attr_writer :authenticate_admin_with, :admin_layout, :admin_path, :back_label, :local_api_token, :throttle_limit,
-                :throttle_period, :hub_secret_key, :hub_api_key, :hub_rules_ttl
-    attr_accessor :hub_url
+    def configure
+      @_configuring = true
+      yield self
+    ensure
+      @_configuring = false
+    end
+
+    # Setters — use configure block; direct assignment is deprecated.
+
+    def authenticate_admin_with=(value)
+      deprecated_direct_setter(:authenticate_admin_with)
+      @authenticate_admin_with = value
+    end
+
+    def admin_layout=(value)
+      deprecated_direct_setter(:admin_layout)
+      @admin_layout = value
+    end
+
+    def admin_path=(value)
+      deprecated_direct_setter(:admin_path)
+      @admin_path = value
+    end
+
+    def back_label=(value)
+      deprecated_direct_setter(:back_label)
+      @back_label = value
+    end
+
+    def local_api_token=(value)
+      deprecated_direct_setter(:local_api_token)
+      @local_api_token = value
+    end
+
+    def throttle_limit=(value)
+      deprecated_direct_setter(:throttle_limit)
+      @throttle_limit = value
+    end
+
+    def throttle_period=(value)
+      deprecated_direct_setter(:throttle_period)
+      @throttle_period = value
+    end
+
+    def hub_url=(value)
+      deprecated_direct_setter(:hub_url)
+      @hub_url = value
+    end
+
+    def hub_secret_key=(value)
+      deprecated_direct_setter(:hub_secret_key)
+      @hub_secret_key = value
+    end
+
+    def hub_api_key=(value)
+      deprecated_direct_setter(:hub_api_key)
+      @hub_api_key = value
+    end
+
+    def hub_rules_ttl=(value)
+      deprecated_direct_setter(:hub_rules_ttl)
+      @hub_rules_ttl = value
+    end
+
+    def adapter=(value)
+      deprecated_direct_setter(:adapter)
+      @adapter = resolve_adapter(value)
+    end
+
+    def disable_on_development=(value)
+      deprecated_direct_setter(:disable_on_development)
+      @disable_on_development = value
+    end
+
+    # Readers
 
     def authenticate_admin_with
       @authenticate_admin_with ||= proc {}
@@ -41,20 +116,36 @@ module Trackguard
       @throttle_period ||= 60
     end
 
+    def hub_url
+      @hub_url ||= "https://app.trackguard.dev"
+    end
+
     def hub_secret_key = @hub_secret_key.to_s
     def hub_api_key    = @hub_api_key.to_s
-    def hub_rules_ttl = @hub_rules_ttl ||= 5.minutes
+    def hub_rules_ttl  = @hub_rules_ttl ||= 5.minutes
 
     def adapter
       @adapter ||= Trackguard::Adapters::Local.new
     end
 
-    def adapter=(value)
-      @adapter = resolve_adapter(value)
+    def disable_on_development
+      @disable_on_development.nil? || @disable_on_development
+    end
+
+    def tracking_enabled?
+      !disable_on_development || !Rails.env.development?
     end
 
     private
 
+    def deprecated_direct_setter(attr)
+      return if @_configuring
+
+      warn "[DEPRECATED] Trackguard.#{attr}= called directly. " \
+           "Use `Trackguard.configure { |c| c.#{attr} = ... }` instead. " \
+           "Direct assignment will be removed in a future version."
+    end
+
     def resolve_adapter(value)
       case value
       when Symbol then Trackguard::Adapters.const_get(value.to_s.camelize).new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trackguard
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Krzysztof Rygielski
@@ -58,8 +58,9 @@ files:
 - app/controllers/trackguard/admin/whitelisted_ips_controller.rb
 - app/controllers/trackguard/page_views_controller.rb
 - app/helpers/trackguard/application_helper.rb
-- app/helpers/trackguard/hub_helper.rb
 - app/jobs/trackguard/detect_suspicious_visitors_job.rb
+- app/jobs/trackguard/hub/submit_blocked_request_job.rb
+- app/jobs/trackguard/hub/submit_page_view_job.rb
 - app/jobs/trackguard/track_blocked_request_job.rb
 - app/jobs/trackguard/track_page_view_job.rb
 - app/models/trackguard/blocked_path.rb
@@ -71,6 +72,7 @@ files:
 - app/models/trackguard/whitelisted_ip.rb
 - app/services/trackguard/analytics_query.rb
 - app/services/trackguard/application_service.rb
+- app/services/trackguard/track_blocked_request.rb
 - app/services/trackguard/track_page_view.rb
 - app/views/layouts/trackguard/admin.html.erb
 - app/views/trackguard/admin/_nav.html.erb
@@ -98,6 +100,7 @@ files:
 - lib/trackguard/adapters/local.rb
 - lib/trackguard/engine.rb
 - lib/trackguard/rack_attack.rb
+- lib/trackguard/trace_id_middleware.rb
 - lib/trackguard/version.rb
 - trackguard.gemspec
 homepage: https://github.com/riggy/trackguard

data/app/helpers/trackguard/hub_helper.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Trackguard
-  module HubHelper
-    def trackguard_hub_js_tag
-      return unless Trackguard.adapter.is_a?(Trackguard::Adapters::Hub)
-
-      tag.script(src: "https://app.trackguard.dev/track.js", data: { api_key: Trackguard.hub_api_key })
-    end
-  end
-end