diff --git a/.cursor/rules/logging_standards.mdc b/.cursor/rules/logging_standards.mdc new file mode 100644 index 00000000..62c075ed --- /dev/null +++ b/.cursor/rules/logging_standards.mdc @@ -0,0 +1,138 @@ +# Agent Contract — TimeSafari Logging (Unified, MANDATORY) + +**Scope:** Applies to all diffs and generated code in this workspace unless explicitly exempted below. +**Goal:** One consistent, rest-parameter logging style using the project logger; no `console.*` in production code. + +## Non‑Negotiables (DO THIS) +- You **MUST** use the project logger; **DO NOT** use any `console.*` methods. +- Import exactly as: + - `import {{ logger }} from '@/utils/logger'` + - If `@` alias is unavailable, compute the correct relative path (do not fail). +- Call signatures use **rest parameters**: `logger.info(message, ...args)` +- Prefer primitives/IDs and small objects in `...args`; **never build a throwaway object** just to “wrap context”. +- Production defaults: Web = `warn+`, Electron = `error`, Dev/Capacitor = `info+` (override via `VITE_LOG_LEVEL`). +- **Database persistence:** `info|warn|error` are persisted; `debug` is not. Use `logger.toDb(msg, level?)` for DB-only. + +## Available Logger API (Authoritative) +- `logger.debug(message, ...args)` — verbose internals, timings, input/output shapes +- `logger.log(message, ...args)` — synonym of `info` for general info +- `logger.info(message, ...args)` — lifecycle, state changes, success paths +- `logger.warn(message, ...args)` — recoverable issues, retries, degraded mode +- `logger.error(message, ...args)` — failures, thrown exceptions, aborts +- `logger.toDb(message, level?)` — DB-only entry (default level = `info`) +- `logger.toConsoleAndDb(message, isError)` — console + DB (use sparingly) +- `logger.withContext(componentName)` — returns a scoped logger + +## Level Guidelines (Use These Heuristics) +### DEBUG +Use for method entry/exit, computed values, filters, loops, retries, and external call payload sizes. +```ts +logger.debug('[HomeView] reloadFeedOnChange() called'); +logger.debug('[HomeView] Current filter settings', settings.filterFeedByVisible, settings.filterFeedByNearby, settings.searchBoxes?.length ?? 0); +logger.debug('[FeedFilters] Toggling nearby filter', this.isNearby, this.settingChanged, this.activeDid); +``` +**Avoid:** Vague messages (`'Processing data'`). + +### INFO +Use for user-visible lifecycle and completed operations. +```ts +logger.info('[StartView] Component mounted', process.env.VITE_PLATFORM); +logger.info('[StartView] User selected new seed generation'); +logger.info('[SearchAreaView] Search box stored', searchBox.name, searchBox.bbox); +logger.info('[ContactQRScanShowView] Contact registration OK', contact.did); +``` +**Avoid:** Diagnostic details that belong in `debug`. + +### WARN +Use for recoverable issues, fallbacks, unexpected-but-handled conditions. +```ts +logger.warn('[ContactQRScanShowView] Invalid scan result – no value', resultType); +logger.warn('[ContactQRScanShowView] Invalid QR format – no JWT in URL'); +logger.warn('[ContactQRScanShowView] JWT missing "own" field'); +``` +**Avoid:** Hard failures (those are `error`). + +### ERROR +Use for unrecoverable failures, data integrity issues, and thrown exceptions. +```ts +logger.error('[HomeView Settings] initializeIdentity() failed', err); +logger.error('[StartView] Failed to load initialization data', error); +logger.error('[ContactQRScanShowView] Error processing contact QR', error, rawValue); +``` +**Avoid:** Expected user cancels (use `info`/`debug`). + +## Context Hygiene (Consistent, Minimal, Helpful) +- **Component context:** Prefer scoped logger. + ```ts + const log = logger.withContext('UserService'); + log.info('User created', userId); + log.error('Failed to create user', error); + ``` + If not using `withContext`, prefix message with `[ComponentName]`. +- **Emojis:** Optional and minimal for visual scanning. Recommended set: + - Start/finish: 🚀 / ✅ • Retry/loop: 🔄 • External call: 📡 • Data/metrics: 📊 • Inspection: 🔍 +- **Sensitive data:** Never log secrets (tokens, keys, passwords) or payloads >10KB. Prefer IDs over objects; redact/hash when needed. + +## Migration — Auto‑Rewrites (Apply Every Time) +- Exact transforms: + - `console.debug(...)` → `logger.debug(...)` + - `console.log(...)` → `logger.log(...)` (or `logger.info(...)` when clearly stateful) + - `console.info(...)` → `logger.info(...)` + - `console.warn(...)` → `logger.warn(...)` + - `console.error(...)` → `logger.error(...)` +- Multi-arg handling: + - First arg becomes `message` (stringify safely if non-string). + - Remaining args map 1:1 to `...args`: + `console.info(msg, a, b)` → `logger.info(String(msg), a, b)` +- Sole `Error`: + - `console.error(err)` → `logger.error(err.message, err)` +- **Object-wrapping cleanup:** Replace `{{ userId, meta }}` wrappers with separate args: + `logger.info('User signed in', userId, meta)` + +## DB Logging Rules +- `debug` **never** persists automatically. +- `info|warn|error` persist automatically. +- For DB-only events (no console), call `logger.toDb('Message', 'info'|'warn'|'error')`. + +## Exceptions (Tightly Scoped) +Allowed paths (still prefer logger): +- `**/*.test.*`, `**/*.spec.*` +- `scripts/dev/**`, `scripts/migrate/**` +To intentionally keep `console.*`, add a pragma on the previous line: +```ts +// cursor:allow-console reason="short justification" +console.log('temporary output'); +``` +Without the pragma, rewrite to `logger.*`. + +## CI & Diff Enforcement +- Do not introduce `console.*` anywhere outside allowed, pragma’d spots. +- If an import is missing, insert it and resolve alias/relative path correctly. +- Enforce rest-parameter call shape in reviews; replace object-wrapped context. +- Ensure environment log level rules remain intact (`VITE_LOG_LEVEL` respected). + +## Quick Before/After +**Before** +```ts +console.log('User signed in', user.id, meta); +console.error('Failed to update profile', err); +console.info('Filter toggled', this.hasVisibleDid); +``` +**After** +```ts +import {{ logger }} from '@/utils/logger'; + +logger.info('User signed in', user.id, meta); +logger.error('Failed to update profile', err); +logger.debug('[FeedFilters] Filter toggled', this.hasVisibleDid); +``` + +## Checklist (for every PR) +- [ ] No `console.*` (or properly pragma’d in the allowed locations) +- [ ] Correct import path for `logger` +- [ ] Rest-parameter call shape (`message, ...args`) +- [ ] Right level chosen (debug/info/warn/error) +- [ ] No secrets / oversized payloads / throwaway context objects +- [ ] Component context provided (scoped logger or `[Component]` prefix) + +_Unified on: 2025-08-15 08:11:46Z_ diff --git a/src/components/FeedFilters.vue b/src/components/FeedFilters.vue index e0ab2f9e..956685e9 100644 --- a/src/components/FeedFilters.vue +++ b/src/components/FeedFilters.vue @@ -101,6 +101,7 @@ import { import { Router } from "vue-router"; import { PlatformServiceMixin } from "@/utils/PlatformServiceMixin"; +import { logger } from "@/utils/logger"; @Component({ components: { @@ -119,11 +120,13 @@ export default class FeedFilters extends Vue { isNearby = false; settingChanged = false; visible = false; + activeDid = ""; - async open(onCloseIfChanged: () => void) { + async open(onCloseIfChanged: () => void, activeDid: string) { this.onCloseIfChanged = onCloseIfChanged; + this.activeDid = activeDid; - const settings = await this.$settings(); + const settings = await this.$accountSettings(activeDid); this.hasVisibleDid = !!settings.filterFeedByVisible; this.isNearby = !!settings.filterFeedByNearby; if (settings.searchBoxes && settings.searchBoxes.length > 0) { @@ -137,6 +140,7 @@ export default class FeedFilters extends Vue { async toggleHasVisibleDid() { this.settingChanged = true; this.hasVisibleDid = !this.hasVisibleDid; + await this.$updateSettings({ filterFeedByVisible: this.hasVisibleDid, }); @@ -145,9 +149,18 @@ export default class FeedFilters extends Vue { async toggleNearby() { this.settingChanged = true; this.isNearby = !this.isNearby; + + logger.debug("[FeedFilters] 🔄 Toggling nearby filter:", { + newValue: this.isNearby, + settingChanged: this.settingChanged, + activeDid: this.activeDid, + }); + await this.$updateSettings({ filterFeedByNearby: this.isNearby, }); + + logger.debug("[FeedFilters] ✅ Nearby filter updated in settings"); } async clearAll() { @@ -179,13 +192,20 @@ export default class FeedFilters extends Vue { } close() { + logger.debug("[FeedFilters] 🚪 Closing dialog:", { + settingChanged: this.settingChanged, + hasCallback: !!this.onCloseIfChanged, + }); + if (this.settingChanged) { + logger.debug("[FeedFilters] 🔄 Settings changed, calling callback"); this.onCloseIfChanged(); } this.visible = false; } done() { + logger.debug("[FeedFilters] ✅ Done button clicked"); this.close(); } } diff --git a/src/views/HomeView.vue b/src/views/HomeView.vue index 4af9b5bc..4aa3523d 100644 --- a/src/views/HomeView.vue +++ b/src/views/HomeView.vue @@ -476,7 +476,7 @@ export default class HomeView extends Vue { // Re-initialize identity with new settings (loads settings internally) await this.initializeIdentity(); } else { - logger.info( + logger.debug( "[HomeView Settings Trace] 📍 DID unchanged, skipping re-initialization", ); } @@ -756,17 +756,34 @@ export default class HomeView extends Vue { * Called by FeedFilters component when filters change */ async reloadFeedOnChange() { - const settings = await this.$accountSettings(this.activeDid, { - filterFeedByVisible: false, - filterFeedByNearby: false, + logger.debug("[HomeView] 🔄 reloadFeedOnChange() called - refreshing feed"); + + // Get current settings without overriding with defaults + const settings = await this.$accountSettings(this.activeDid); + + logger.debug("[HomeView] 📊 Current filter settings:", { + filterFeedByVisible: settings.filterFeedByVisible, + filterFeedByNearby: settings.filterFeedByNearby, + searchBoxes: settings.searchBoxes?.length || 0, }); + this.isFeedFilteredByVisible = !!settings.filterFeedByVisible; this.isFeedFilteredByNearby = !!settings.filterFeedByNearby; this.isAnyFeedFilterOn = checkIsAnyFeedFilterOn(settings); + logger.debug("[HomeView] 🎯 Updated filter states:", { + isFeedFilteredByVisible: this.isFeedFilteredByVisible, + isFeedFilteredByNearby: this.isFeedFilteredByNearby, + isAnyFeedFilterOn: this.isAnyFeedFilterOn, + }); + this.feedData = []; this.feedPreviousOldestId = undefined; + + logger.debug("[HomeView] 🧹 Cleared feed data, calling updateAllFeed()"); await this.updateAllFeed(); + + logger.debug("[HomeView] ✅ Feed refresh completed"); } /** @@ -845,6 +862,14 @@ export default class HomeView extends Vue { * - this.feedLastViewedClaimId (via updateFeedLastViewedId) */ async updateAllFeed() { + logger.debug("[HomeView] 🚀 updateAllFeed() called", { + isFeedLoading: this.isFeedLoading, + currentFeedDataLength: this.feedData.length, + isAnyFeedFilterOn: this.isAnyFeedFilterOn, + isFeedFilteredByVisible: this.isFeedFilteredByVisible, + isFeedFilteredByNearby: this.isFeedFilteredByNearby, + }); + this.isFeedLoading = true; let endOfResults = true; @@ -853,21 +878,37 @@ export default class HomeView extends Vue { this.apiServer, this.feedPreviousOldestId, ); + + logger.debug("[HomeView] 📡 Retrieved gives from API", { + resultsCount: results.data.length, + endOfResults, + }); + if (results.data.length > 0) { endOfResults = false; // gather any contacts that user has blocked from view await this.processFeedResults(results.data); await this.updateFeedLastViewedId(results.data); + + logger.debug("[HomeView] 📝 Processed feed results", { + processedCount: this.feedData.length, + }); } } catch (e) { + logger.error("[HomeView] ❌ Error in updateAllFeed:", e); this.handleFeedError(e); } if (this.feedData.length === 0 && !endOfResults) { + logger.debug("[HomeView] 🔄 No results after filtering, retrying..."); await this.updateAllFeed(); } this.isFeedLoading = false; + logger.debug("[HomeView] ✅ updateAllFeed() completed", { + finalFeedDataLength: this.feedData.length, + isFeedLoading: this.isFeedLoading, + }); } /** @@ -892,12 +933,35 @@ export default class HomeView extends Vue { * @param records Array of feed records to process */ private async processFeedResults(records: GiveSummaryRecord[]) { + logger.debug("[HomeView] 📝 Processing feed results:", { + inputRecords: records.length, + currentFilters: { + isAnyFeedFilterOn: this.isAnyFeedFilterOn, + isFeedFilteredByVisible: this.isFeedFilteredByVisible, + isFeedFilteredByNearby: this.isFeedFilteredByNearby, + }, + }); + + let processedCount = 0; + let filteredCount = 0; + for (const record of records) { const processedRecord = await this.processRecord(record); if (processedRecord) { this.feedData.push(processedRecord); + processedCount++; + } else { + filteredCount++; } } + + logger.debug("[HomeView] 📊 Feed processing results:", { + processed: processedCount, + filtered: filteredCount, + total: records.length, + finalFeedLength: this.feedData.length, + }); + this.feedPreviousOldestId = records[records.length - 1].jwtId; } @@ -931,7 +995,7 @@ export default class HomeView extends Vue { * - this.feedData (via createFeedRecord) * * @param record The record to process - * @returns Processed record with contact info if it passes filters, null otherwise + * @returns Processed record if it passes filters, null otherwise */ private async processRecord( record: GiveSummaryRecord, @@ -941,13 +1005,28 @@ export default class HomeView extends Vue { const recipientDid = this.extractRecipientDid(claim); const fulfillsPlan = await this.getFulfillsPlan(record); + + // Log record details for debugging + logger.debug("[HomeView] 🔍 Processing record:", { + recordId: record.jwtId, + hasFulfillsPlan: !!fulfillsPlan, + fulfillsPlanHandleId: record.fulfillsPlanHandleId, + filters: { + isAnyFeedFilterOn: this.isAnyFeedFilterOn, + isFeedFilteredByVisible: this.isFeedFilteredByNearby, + isFeedFilteredByNearby: this.isFeedFilteredByNearby, + }, + }); + if (!this.shouldIncludeRecord(record, fulfillsPlan)) { + logger.debug("[HomeView] ❌ Record filtered out:", record.jwtId); return null; } const provider = this.extractProvider(claim); const providedByPlan = await this.getProvidedByPlan(provider); + logger.debug("[HomeView] ✅ Record included:", record.jwtId); return this.createFeedRecord( record, claim, @@ -1096,6 +1175,22 @@ export default class HomeView extends Vue { } } + // Add debug logging for nearby filter + if (this.isFeedFilteredByNearby && record.fulfillsPlanHandleId) { + logger.debug("[HomeView] 🔍 Nearby filter check:", { + recordId: record.jwtId, + hasFulfillsPlan: !!fulfillsPlan, + hasLocation: !!(fulfillsPlan?.locLat && fulfillsPlan?.locLon), + location: fulfillsPlan + ? { lat: fulfillsPlan.locLat, lon: fulfillsPlan.locLon } + : null, + inSearchBox: fulfillsPlan + ? this.latLongInAnySearchBox(fulfillsPlan.locLat, fulfillsPlan.locLon) + : null, + finalResult: anyMatch, + }); + } + return anyMatch; } @@ -1531,7 +1626,10 @@ export default class HomeView extends Vue { * Called by template click handler */ openFeedFilters() { - (this.$refs.feedFilters as FeedFilters).open(this.reloadFeedOnChange); + (this.$refs.feedFilters as FeedFilters).open( + this.reloadFeedOnChange, + this.activeDid, + ); } /**