Do not store image in cache if error

AGENTS.md

@@ -0,0 +1,26 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+Dawarich is a Rails 8 monolith. Controllers, models, jobs, services, policies, and Stimulus/Turbo JS live in `app/`, while shared POROs sit in `lib/`. Configuration, credentials, and cron/Sidekiq settings live in `config/`; API documentation assets are in `swagger/`. Database migrations and seeds live in `db/`, Docker tooling sits in `docker/`, and docs or media live in `docs/` and `screenshots/`. Runtime artifacts in `storage/`, `tmp/`, and `log/` stay untracked.
+
+## Architecture & Key Services
+The stack pairs Rails 8 with PostgreSQL + PostGIS, Redis-backed Sidekiq, Devise/Pundit, Tailwind + DaisyUI, and Leaflet/Chartkick. Imports, exports, sharing, and trip analytics lean on PostGIS geometries plus workers, so queue anything non-trivial instead of blocking requests.
+
+## Build, Test, and Development Commands
+- `docker compose -f docker/docker-compose.yml up` — launches the full stack for smoke tests.
+- `bundle exec rails db:prepare` — create/migrate the PostGIS database.
+- `bundle exec bin/dev` and `bundle exec sidekiq` — start the web/Vite/Tailwind stack and workers locally.
+- `make test` — runs Playwright (`npx playwright test e2e --workers=1`) then `bundle exec rspec`.
+- `bundle exec rubocop` / `npx prettier --check app/javascript` — enforce formatting before commits.
+
+## Coding Style & Naming Conventions
+Use two-space indentation, snake_case filenames, and CamelCase classes. Keep Stimulus controllers under `app/javascript/controllers/*_controller.ts` so names match DOM `data-controller` hooks. Prefer service objects in `app/services/` for multi-step imports/exports, and let migrations named like `202405061210_add_indexes_to_events` manage schema changes. Follow Tailwind ordering conventions and avoid bespoke CSS unless necessary.
+
+## Testing Guidelines
+RSpec mirrors the app hierarchy inside `spec/` with files suffixed `_spec.rb`; rely on FactoryBot/FFaker for data, WebMock for HTTP, and SimpleCov for coverage. Browser journeys live in `e2e/` and should use `data-testid` selectors plus seeded demo data to reset state. Run `make test` before pushing and document intentional gaps when coverage dips.
+
+## Commit & Pull Request Guidelines
+Write short, imperative commit subjects (`Add globe_projection setting`) and include the PR/issue reference like `(#2138)` when relevant. Target `dev`, describe migrations, configs, and verification steps, and attach screenshots or curl examples for UI/API work. Link related Discussions for larger changes and request review from domain owners (imports, sharing, trips, etc.).
+
+## Security & Configuration Tips
+Start from `.env.example` or `.env.template` and store secrets in encrypted Rails credentials; never commit files from `gps-env/` or real trace data. Rotate API keys, scrub sensitive coordinates in fixtures, and use the synthetic traces in `db/seeds.rb` when demonstrating imports.

CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+# [0.37.3] - Unreleased
+
+## Fixed
+
+- Routes are now being drawn the very same way on Map V2 as in Map V1. #2132 #2086
+- RailsPulse performance monitoring is now disabled for self-hosted instances. It fixes poor performance on Synology. #2139
+
+## Changed
+
+- Map V2 points loading is significantly sped up.
+- Points size on Map V2 was reduced to prevent overlapping.
+- Points sent from Owntracks and Overland are now being created synchronously to instantly reflect success or failure of point creation.
+
 # [0.37.2] - 2026-01-04
 
 ## Fixed
@@ -12,6 +25,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Time spent in a country and city is now calculated correctly for the year-end digest email. #2104
 - Updated Trix to fix a XSS vulnerability. #2102
 - Map v2 UI no longer blocks when Immich/Photoprism integration has a bad URL or is unreachable. Added 10-second timeout to photo API requests and improved error handling to prevent UI freezing during initial load. #2085
+
+## Added
 - In Map v2 settings, you can now enable map to be rendered as a globe.
 
 # [0.37.1] - 2025-12-30

CLAUDE.md

@@ -238,6 +238,47 @@ bundle exec bundle-audit             # Dependency security
    - Respect expiration settings and disable sharing when expired
    - Only expose minimal necessary data in public sharing contexts
 
+### Route Drawing Implementation (Critical)
+
+⚠️ **IMPORTANT: Unit Mismatch in Route Splitting Logic**
+
+Both Map v1 (Leaflet) and Map v2 (MapLibre) contain an **intentional unit mismatch** in route drawing that must be preserved for consistency:
+
+**The Issue**:
+- `haversineDistance()` function returns distance in **kilometers** (e.g., 0.5 km)
+- Route splitting threshold is stored and compared as **meters** (e.g., 500)
+- The code compares them directly: `0.5 > 500` = always **FALSE**
+
+**Result**:
+- The distance threshold (`meters_between_routes` setting) is **effectively disabled**
+- Routes only split on **time gaps** (default: 60 minutes between points)
+- This creates longer, more continuous routes that users expect
+
+**Code Locations**:
+- **Map v1**: `app/javascript/maps/polylines.js:390`
+  - Uses `haversineDistance()` from `maps/helpers.js` (returns km)
+  - Compares to `distanceThresholdMeters` variable (value in meters)
+
+- **Map v2**: `app/javascript/maps_maplibre/layers/routes_layer.js:82-104`
+  - Has built-in `haversineDistance()` method (returns km)
+  - Intentionally skips `/1000` conversion to replicate v1 behavior
+  - Comment explains this is matching v1's unit mismatch
+
+**Critical Rules**:
+1. ❌ **DO NOT "fix" the unit mismatch** - this would break user expectations
+2. ✅ **Keep both versions synchronized** - they must behave identically
+3. ✅ **Document any changes** - route drawing changes affect all users
+4. ⚠️ If you ever fix this bug:
+   - You MUST update both v1 and v2 simultaneously
+   - You MUST migrate user settings (multiply existing values by 1000 or divide by 1000 depending on direction)
+   - You MUST communicate the breaking change to users
+
+**Additional Route Drawing Details**:
+- **Time threshold**: 60 minutes (default) - actually functional
+- **Distance threshold**: 500 meters (default) - currently non-functional due to unit bug
+- **Sorting**: Map v2 sorts points by timestamp client-side; v1 relies on backend ASC order
+- **API ordering**: Map v2 must request `order: 'asc'` to match v1's chronological data flow
+
 ## Contributing
 
 - **Main Branch**: `master`

app/controllers/api/v1/overland/batches_controller.rb

@@ -5,9 +5,13 @@ class Api::V1::Overland::BatchesController < ApiController
   before_action :validate_points_limit, only: %i[create]
 
   def create
-    Overland::BatchCreatingJob.perform_later(batch_params, current_api_user.id)
+    Overland::PointsCreator.new(batch_params, current_api_user.id).call
 
     render json: { result: 'ok' }, status: :created
+  rescue StandardError => e
+    Sentry.capture_exception(e) if defined?(Sentry)
+
+    render json: { error: 'Batch creation failed' }, status: :internal_server_error
   end
 
   private

app/controllers/api/v1/owntracks/points_controller.rb

@@ -5,9 +5,13 @@ class Api::V1::Owntracks::PointsController < ApiController
   before_action :validate_points_limit, only: %i[create]
 
   def create
-    Owntracks::PointCreatingJob.perform_later(point_params, current_api_user.id)
+    OwnTracks::PointCreator.new(point_params, current_api_user.id).call
 
-    render json: {}, status: :ok
+    render json: [], status: :ok
+  rescue StandardError => e
+    Sentry.capture_exception(e) if defined?(Sentry)
+
+    render json: { error: 'Point creation failed' }, status: :internal_server_error
   end
 
   private

app/controllers/api/v1/photos_controller.rb

@@ -20,9 +20,16 @@ def thumbnail
   private
 
   def fetch_cached_thumbnail(source)
-    Rails.cache.fetch("photo_thumbnail_#{params[:id]}", expires_in: 1.day) do
-      Photos::Thumbnail.new(current_api_user, source, params[:id]).call
+    cached = Rails.cache.read("photo_thumbnail_#{params[:id]}")
+    return cached if cached
+
+    response = Photos::Thumbnail.new(current_api_user, source, params[:id]).call
+
+    if response.success?
+      Rails.cache.write("photo_thumbnail_#{params[:id]}", response, expires_in: 1.day)
     end
+
+    response
   end
 
   def handle_thumbnail_response(response)

app/controllers/api/v1/places_controller.rb

@@ -16,11 +16,11 @@ def index
           include_untagged = tag_ids.include?('untagged')
 
           if numeric_tag_ids.any? && include_untagged
-            # Both tagged and untagged: return union (OR logic)
-            tagged = current_api_user.places.includes(:tags, :visits).with_tags(numeric_tag_ids)
-            untagged = current_api_user.places.includes(:tags, :visits).without_tags
-            @places = Place.from("(#{tagged.to_sql} UNION #{untagged.to_sql}) AS places")
-                           .includes(:tags, :visits)
+            # Both tagged and untagged: use OR logic to preserve eager loading
+            tagged_ids = current_api_user.places.with_tags(numeric_tag_ids).pluck(:id)
+            untagged_ids = current_api_user.places.without_tags.pluck(:id)
+            combined_ids = (tagged_ids + untagged_ids).uniq
+            @places = current_api_user.places.includes(:tags, :visits).where(id: combined_ids)
           elsif numeric_tag_ids.any?
             # Only tagged places with ANY of the selected tags (OR logic)
             @places = @places.with_tags(numeric_tag_ids)
@@ -30,6 +30,29 @@ def index
           end
         end
 
+        # Support pagination (defaults to page 1 with all results if no page param)
+        page = params[:page].presence || 1
+        per_page = [params[:per_page]&.to_i || 100, 500].min
+
+        # Apply pagination only if page param is explicitly provided
+        if params[:page].present?
+          @places = @places.page(page).per(per_page)
+        end
+
+        # Always set pagination headers for consistency
+        if @places.respond_to?(:current_page)
+          # Paginated collection
+          response.set_header('X-Current-Page', @places.current_page.to_s)
+          response.set_header('X-Total-Pages', @places.total_pages.to_s)
+          response.set_header('X-Total-Count', @places.total_count.to_s)
+        else
+          # Non-paginated collection - treat as single page with all results
+          total = @places.count
+          response.set_header('X-Current-Page', '1')
+          response.set_header('X-Total-Pages', '1')
+          response.set_header('X-Total-Count', total.to_s)
+        end
+
         render json: @places.map { |place| serialize_place(place) }
       end
 
@@ -120,7 +143,7 @@ def serialize_place(place)
           note: place.note,
           icon: place.tags.first&.icon,
           color: place.tags.first&.color,
-          visits_count: place.visits.count,
+          visits_count: place.visits.size,
           created_at: place.created_at,
           tags: place.tags.map do |tag|
             {

app/controllers/api/v1/points_controller.rb

@@ -53,9 +53,11 @@ def create
   def update
     point = current_api_user.points.find(params[:id])
 
-    point.update(lonlat: "POINT(#{point_params[:longitude]} #{point_params[:latitude]})")
-
-    render json: point_serializer.new(point).call
+    if point.update(lonlat: "POINT(#{point_params[:longitude]} #{point_params[:latitude]})")
+      render json: point_serializer.new(point.reload).call
+    else
+      render json: { error: point.errors.full_messages.join(', ') }, status: :unprocessable_entity
+    end
   end
 
   def destroy

app/controllers/api/v1/tracks_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Api::V1::TracksController < ApiController
+  def index
+    tracks_query = Tracks::IndexQuery.new(user: current_api_user, params: params)
+    paginated_tracks = tracks_query.call
+
+    geojson = Tracks::GeojsonSerializer.new(paginated_tracks).call
+
+    tracks_query.pagination_headers(paginated_tracks).each do |header, value|
+      response.set_header(header, value)
+    end
+
+    render json: geojson
+  end
+end

app/controllers/api/v1/visits_controller.rb

@@ -3,6 +3,17 @@
 class Api::V1::VisitsController < ApiController
   def index
     visits = Visits::Finder.new(current_api_user, params).call
+
+    # Support optional pagination (backward compatible - returns all if no page param)
+    if params[:page].present?
+      per_page = [params[:per_page]&.to_i || 100, 500].min
+      visits = visits.page(params[:page]).per(per_page)
+
+      response.set_header('X-Current-Page', visits.current_page.to_s)
+      response.set_header('X-Total-Pages', visits.total_pages.to_s)
+      response.set_header('X-Total-Count', visits.total_count.to_s)
+    end
+
     serialized_visits = visits.map do |visit|
       Api::VisitSerializer.new(visit).call
     end

app/controllers/map/leaflet_controller.rb

@@ -41,19 +41,34 @@ def build_tracks
   end
 
   def calculate_distance
-    return 0 if @coordinates.size < 2
-
-    total_distance = 0
-
-    @coordinates.each_cons(2) do
-      distance_km = Geocoder::Calculations.distance_between(
-        [_1[0], _1[1]], [_2[0], _2[1]], units: :km
-      )
-
-      total_distance += distance_km
-    end
-
-    total_distance.round
+    return 0 if @points.count(:id) < 2
+
+    # Use PostGIS window function for efficient distance calculation
+    # This is O(1) database operation vs O(n) Ruby iteration
+    import_filter = params[:import_id].present? ? 'AND import_id = :import_id' : ''
+
+    sql = <<~SQL.squish
+      SELECT COALESCE(SUM(distance_m) / 1000.0, 0) as total_km FROM (
+        SELECT ST_Distance(
+          lonlat::geography,
+          LAG(lonlat::geography) OVER (ORDER BY timestamp)
+        ) as distance_m
+        FROM points
+        WHERE user_id = :user_id
+          AND timestamp >= :start_at
+          AND timestamp <= :end_at
+          #{import_filter}
+      ) distances
+    SQL
+
+    query_params = { user_id: current_user.id, start_at: start_at, end_at: end_at }
+    query_params[:import_id] = params[:import_id] if params[:import_id].present?
+
+    result = Point.connection.select_value(
+      ActiveRecord::Base.sanitize_sql_array([sql, query_params])
+    )
+
+    result&.to_f&.round || 0
   end
 
   def parsed_start_at

app/controllers/stats_controller.rb

@@ -80,8 +80,12 @@ def precompute_year_distances
   end
 
   def build_stats
-    current_user.stats.group_by(&:year).transform_values do |stats|
-      stats.sort_by(&:updated_at).reverse
-    end.sort.reverse
+    columns = %i[id year month distance updated_at user_id]
+    columns << :toponyms if DawarichSettings.reverse_geocoding_enabled?
+
+    current_user.stats
+                .select(columns)
+                .order(year: :desc, updated_at: :desc)
+                .group_by(&:year)
   end
 end