Ensured all logging goes over the logger

src/components/Note/MarkdownArticle/MarkdownArticle.tsx

@@ -20,6 +20,7 @@ import EmbeddedCitation from '@/components/EmbeddedCitation'
 import { preprocessMarkdownMediaLinks } from './preprocessMarkup'
 import katex from 'katex'
 import 'katex/dist/katex.min.css'
+import logger from '@/lib/logger'
 
 /**
  * Truncate link display text to 200 characters, adding ellipsis if truncated
@@ -120,7 +121,7 @@ function CodeBlock({ id, code, language }: { id: string; code: string; language:
             hljs.default.highlightElement(codeRef.current)
           }
         } catch (error) {
-          console.error('Error loading highlight.js:', error)
+          logger.error('Error loading highlight.js:', error)
         }
       }
     }
@@ -184,7 +185,7 @@ function InlineCode({ code, keyPrefix }: { code: string; keyPrefix: string }) {
           displayMode: false
         })
       } catch (error) {
-        console.error('Error rendering LaTeX inline math:', error)
+        logger.error('Error rendering LaTeX inline math:', error)
         // On error, fall back to showing the code as-is
         if (elementRef.current) {
           elementRef.current.textContent = code

src/components/Profile/ProfileInteractions.tsx

@@ -8,6 +8,7 @@ import client from '@/services/client.service'
 import { FAST_READ_RELAY_URLS } from '@/constants'
 import { normalizeUrl } from '@/lib/url'
 import { useZap } from '@/providers/ZapProvider'
+import logger from '@/lib/logger'
 
 const INITIAL_SHOW_COUNT = 25
 const LOAD_MORE_COUNT = 25
@@ -178,7 +179,7 @@ const ProfileInteractions = forwardRef<
         
         setEvents(uniqueEvents)
       } catch (error) {
-        console.error('Failed to fetch interactions', error)
+        logger.error('Failed to fetch interactions', error)
         setEvents([])
       } finally {
         setIsLoading(false)

src/pages/secondary/RssFeedSettingsPage/index.tsx

@@ -250,24 +250,24 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
         tags: event.tags,
         created_at: event.created_at 
       })
-      console.log('✅ [RSS] Event created with tags', {
+      logger.debug('[RSS] Event created with tags', {
         kind: event.kind,
         tagCount: event.tags.length,
         tags: event.tags
       })
       
-      console.log('🔵 [RSS] About to call publish()')
+      logger.debug('[RSS] About to call publish()')
       let result
       try {
         result = await publish(event)
-        console.log('✅ [RSS] Event published successfully!', {
+        logger.debug('[RSS] Event published successfully!', {
           id: result.id,
           kind: result.kind,
           pubkey: result.pubkey?.substring(0, 8),
           content: result.content
         })
       } catch (publishError) {
-        console.error('❌ [RSS] Publish failed!', publishError)
+        logger.error('[RSS] Publish failed!', publishError)
         throw publishError
       }
       
@@ -280,7 +280,7 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
       })
       
       // Cache the event in IndexedDB for immediate access
-      console.log('🔵 [RSS] About to cache event in IndexedDB', {
+      logger.debug('[RSS] About to cache event in IndexedDB', {
         eventId: result.id,
         kind: result.kind,
         pubkey: result.pubkey?.substring(0, 8)
@@ -293,9 +293,9 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
           pubkey: result.pubkey 
         })
         
-        console.log('🔵 [RSS] Calling indexedDb.putReplaceableEvent()...')
+        logger.debug('[RSS] Calling indexedDb.putReplaceableEvent()...')
         const savedEvent = await indexedDb.putReplaceableEvent(result)
-        console.log('✅ [RSS] Successfully cached to IndexedDB!', {
+        logger.debug('[RSS] Successfully cached to IndexedDB!', {
           eventId: savedEvent.id,
           kind: savedEvent.kind,
           pubkey: savedEvent.pubkey?.substring(0, 8),
@@ -308,7 +308,7 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
           feedCount: feedUrls.length 
         })
       } catch (cacheError) {
-        console.error('❌ [RSS] Failed to cache to IndexedDB!', {
+        logger.error('[RSS] Failed to cache to IndexedDB!', {
           error: cacheError,
           errorMessage: cacheError instanceof Error ? cacheError.message : String(cacheError),
           errorStack: cacheError instanceof Error ? cacheError.stack : undefined,
@@ -324,7 +324,7 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
       }
       
       // Verify the event was saved by reading it back
-      console.log('🔵 [RSS] Verifying event was saved...')
+      logger.debug('[RSS] Verifying event was saved...')
       try {
         logger.info('[RssFeedSettingsPage] Verifying event was saved to IndexedDB', { 
           pubkey: pubkey.substring(0, 8),
@@ -333,7 +333,7 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
         
         const savedEvent = await indexedDb.getReplaceableEvent(pubkey, ExtendedKind.RSS_FEED_LIST)
         if (savedEvent) {
-          console.log('✅ [RSS] Event found in IndexedDB!', {
+          logger.debug('[RSS] Event found in IndexedDB!', {
             eventId: savedEvent.id,
             expectedId: result.id,
             match: savedEvent.id === result.id,
@@ -348,10 +348,10 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
           })
           
           if (savedEvent.id === result.id) {
-            console.log('✅ [RSS] Event IDs match! Verification successful!')
+            logger.debug('[RSS] Event IDs match! Verification successful!')
             logger.info('[RssFeedSettingsPage] Verified RSS feed list event in IndexedDB', { eventId: savedEvent.id })
           } else {
-            console.warn('⚠️ [RSS] Event ID mismatch!', {
+            logger.warn('[RSS] Event ID mismatch!', {
               expectedId: result.id,
               foundId: savedEvent.id
             })
@@ -363,7 +363,7 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
             })
           }
         } else {
-          console.error('❌ [RSS] Event NOT found in IndexedDB after save!', {
+          logger.error('[RSS] Event NOT found in IndexedDB after save!', {
             expectedId: result.id,
             pubkey: pubkey.substring(0, 8),
             kind: ExtendedKind.RSS_FEED_LIST 
@@ -375,7 +375,7 @@ const RssFeedSettingsPage = forwardRef(({ index, hideTitlebar = false }: { index
           })
         }
       } catch (verifyError) {
-        console.error('❌ [RSS] Error verifying event in IndexedDB!', verifyError)
+        logger.error('[RSS] Error verifying event in IndexedDB!', verifyError)
         logger.error('[RssFeedSettingsPage] Failed to verify RSS feed list event in IndexedDB', { 
           error: verifyError,
           pubkey: pubkey.substring(0, 8),

src/providers/NostrProvider/index.tsx

@@ -886,14 +886,14 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
       }
     }
 
-    console.log('🔵 [Publish] Determining target relays...', { kind: event.kind, pubkey: event.pubkey?.substring(0, 8) })
+    logger.debug('[Publish] Determining target relays...', { kind: event.kind, pubkey: event.pubkey?.substring(0, 8) })
     const relays = await client.determineTargetRelays(event, options)
-    console.log('✅ [Publish] Target relays determined', { relayCount: relays.length, relays: relays.slice(0, 5) })
+    logger.debug('[Publish] Target relays determined', { relayCount: relays.length, relays: relays.slice(0, 5) })
 
     try {
-      console.log('🔵 [Publish] Calling client.publishEvent()...', { relayCount: relays.length, eventId: event.id?.substring(0, 8) })
+      logger.debug('[Publish] Calling client.publishEvent()...', { relayCount: relays.length, eventId: event.id?.substring(0, 8) })
       const publishResult = await client.publishEvent(relays, event)
-      console.log('✅ [Publish] publishEvent completed', {
+      logger.debug('[Publish] publishEvent completed', {
         success: publishResult.success,
         successCount: publishResult.successCount,
         totalCount: publishResult.totalCount,
@@ -906,7 +906,7 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
       
       // If publishing failed completely, throw an error so the form doesn't close
       if (!publishResult.success) {
-        console.error('❌ [Publish] Publishing failed to all relays!', {
+        logger.error('[Publish] Publishing failed to all relays!', {
           relayStatuses: publishResult.relayStatuses
         })
         const error = new AggregateError(
@@ -919,7 +919,7 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
         throw error
       }
       
-      console.log('✅ [Publish] Publishing successful, attaching relayStatuses to event')
+      logger.debug('[Publish] Publishing successful, attaching relayStatuses to event')
       // Attach relayStatuses only temporarily for UI feedback, then remove it
       // This prevents it from being included in the event when serialized
       // Use a longer delay to ensure UI components can read it before deletion
@@ -936,7 +936,7 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
       // This ensures replies appear immediately in the note view
       client.emitNewEvent(event)
       
-      console.log('✅ [Publish] Returning event', { eventId: event.id?.substring(0, 8), hasRelayStatuses: !!relayStatuses })
+      logger.debug('[Publish] Returning event', { eventId: event.id?.substring(0, 8), hasRelayStatuses: !!relayStatuses })
       return event
     } catch (error) {
       // Check for authentication-related errors

src/services/client.service.ts

@@ -178,14 +178,14 @@ class ClientService extends EventTarget {
   }
 
   async publishEvent(relayUrls: string[], event: NEvent) {
-    console.log('🔵 [PublishEvent] Starting publishEvent', {
+    logger.debug('[PublishEvent] Starting publishEvent', {
       eventId: event.id?.substring(0, 8),
       kind: event.kind,
       relayCount: relayUrls.length
     })
     
     const uniqueRelayUrls = Array.from(new Set(relayUrls))
-    console.log('🔵 [PublishEvent] Unique relays', { count: uniqueRelayUrls.length, relays: uniqueRelayUrls.slice(0, 5) })
+    logger.debug('[PublishEvent] Unique relays', { count: uniqueRelayUrls.length, relays: uniqueRelayUrls.slice(0, 5) })
     
     const relayStatuses: { url: string; success: boolean; error?: string }[] = []
     
@@ -194,17 +194,17 @@ class ClientService extends EventTarget {
       let finishedCount = 0
       const errors: { url: string; error: any }[] = []
       
-      console.log('🔵 [PublishEvent] Setting up global timeout (30 seconds)')
+      logger.debug('[PublishEvent] Setting up global timeout (30 seconds)')
       let hasResolved = false
       
       // Add a global timeout to prevent hanging - use 30 seconds for faster feedback
       const globalTimeout = setTimeout(() => {
         if (hasResolved) {
-          console.log('🔵 [PublishEvent] Already resolved, ignoring timeout')
+          logger.debug('[PublishEvent] Already resolved, ignoring timeout')
           return
         }
         
-        console.warn('⚠️ [PublishEvent] Global timeout reached!', {
+        logger.warn('[PublishEvent] Global timeout reached!', {
           finishedCount,
           totalRelays: uniqueRelayUrls.length,
           successCount,
@@ -215,7 +215,7 @@ class ClientService extends EventTarget {
         uniqueRelayUrls.forEach(url => {
           const alreadyFinished = relayStatuses.some(rs => rs.url === url)
           if (!alreadyFinished) {
-            console.warn('⚠️ [PublishEvent] Marking relay as timed out', { url })
+            logger.warn('[PublishEvent] Marking relay as timed out', { url })
             relayStatuses.push({ url, success: false, error: 'Timeout: Operation took too long' })
             finishedCount++
           }
@@ -224,7 +224,7 @@ class ClientService extends EventTarget {
         // Ensure we resolve even if not all relays finished
         if (!hasResolved) {
           hasResolved = true
-          console.log('✅ [PublishEvent] Resolving due to timeout', {
+          logger.debug('[PublishEvent] Resolving due to timeout', {
             success: successCount >= uniqueRelayUrls.length / 3,
             successCount,
             totalCount: uniqueRelayUrls.length,
@@ -239,10 +239,10 @@ class ClientService extends EventTarget {
         }
       }, 30_000) // 30 seconds global timeout (reduced from 2 minutes)
       
-      console.log('🔵 [PublishEvent] Starting Promise.allSettled for all relays')
+      logger.debug('[PublishEvent] Starting Promise.allSettled for all relays')
       Promise.allSettled(
         uniqueRelayUrls.map(async (url, index) => {
-          console.log(`🔵 [PublishEvent] Starting relay ${index + 1}/${uniqueRelayUrls.length}`, { url })
+          logger.debug(`[PublishEvent] Starting relay ${index + 1}/${uniqueRelayUrls.length}`, { url })
           // eslint-disable-next-line @typescript-eslint/no-this-alias
           const that = this
           const isLocal = isLocalNetworkUrl(url)
@@ -251,14 +251,14 @@ class ClientService extends EventTarget {
           
           // Set up a per-relay timeout to ensure we always reach the finally block
           const relayTimeout = setTimeout(() => {
-            console.warn(`⚠️ [PublishEvent] Per-relay timeout for ${url}`, { connectionTimeout, publishTimeout })
+            logger.warn(`[PublishEvent] Per-relay timeout for ${url}`, { connectionTimeout, publishTimeout })
             // This will be caught in the catch block if the promise is still pending
           }, connectionTimeout + publishTimeout + 2_000) // Add 2s buffer
           
           try {
             // For local relays, add a connection timeout
             let relay: Relay
-            console.log(`🔵 [PublishEvent] Ensuring relay connection`, { url, isLocal, connectionTimeout })
+            logger.debug(`[PublishEvent] Ensuring relay connection`, { url, isLocal, connectionTimeout })
             
             const connectionPromise = isLocal
               ? Promise.race([
@@ -275,48 +275,48 @@ class ClientService extends EventTarget {
                 ])
             
             relay = await connectionPromise
-            console.log(`✅ [PublishEvent] Relay connected`, { url })
+            logger.debug(`[PublishEvent] Relay connected`, { url })
             
             relay.publishTimeout = publishTimeout
             
-            console.log(`🔵 [PublishEvent] Publishing to relay`, { url })
+            logger.debug(`[PublishEvent] Publishing to relay`, { url })
             
             // Wrap publish in a timeout promise
             const publishPromise = relay
               .publish(event)
               .then(() => {
-                console.log(`✅ [PublishEvent] Successfully published to relay`, { url })
+                logger.debug(`[PublishEvent] Successfully published to relay`, { url })
                 this.trackEventSeenOn(event.id, relay)
                 successCount++
                 relayStatuses.push({ url, success: true })
               })
               .catch((error) => {
-                console.warn(`⚠️ [PublishEvent] Publish failed, checking if auth required`, { url, error: error.message })
+                logger.warn(`[PublishEvent] Publish failed, checking if auth required`, { url, error: error.message })
                 if (
                   error instanceof Error &&
                   error.message.startsWith('auth-required') &&
                   !!that.signer
                 ) {
-                  console.log(`🔵 [PublishEvent] Auth required, attempting authentication`, { url })
+                  logger.debug(`[PublishEvent] Auth required, attempting authentication`, { url })
                   return relay
                     .auth((authEvt: EventTemplate) => that.signer!.signEvent(authEvt))
                     .then(() => {
-                      console.log(`✅ [PublishEvent] Auth successful, retrying publish`, { url })
+                      logger.debug(`[PublishEvent] Auth successful, retrying publish`, { url })
                       return relay.publish(event)
                     })
                     .then(() => {
-                      console.log(`✅ [PublishEvent] Successfully published after auth`, { url })
+                      logger.debug(`[PublishEvent] Successfully published after auth`, { url })
                       this.trackEventSeenOn(event.id, relay)
                       successCount++
                       relayStatuses.push({ url, success: true })
                     })
                     .catch((authError) => {
-                      console.error(`❌ [PublishEvent] Auth or publish failed`, { url, error: authError.message })
+                      logger.error(`[PublishEvent] Auth or publish failed`, { url, error: authError.message })
                       errors.push({ url, error: authError })
                       relayStatuses.push({ url, success: false, error: authError.message })
                     })
                 } else {
-                  console.error(`❌ [PublishEvent] Publish failed`, { url, error: error.message })
+                  logger.error(`[PublishEvent] Publish failed`, { url, error: error.message })
                   errors.push({ url, error })
                   relayStatuses.push({ url, success: false, error: error.message })
                 }
@@ -330,7 +330,7 @@ class ClientService extends EventTarget {
               )
             ])
           } catch (error) {
-            console.error(`❌ [PublishEvent] Connection or setup failed`, { url, error: error instanceof Error ? error.message : String(error) })
+            logger.error(`[PublishEvent] Connection or setup failed`, { url, error: error instanceof Error ? error.message : String(error) })
             errors.push({ url, error })
             relayStatuses.push({ 
               url, 
@@ -340,7 +340,7 @@ class ClientService extends EventTarget {
           } finally {
             clearTimeout(relayTimeout)
             const currentFinished = ++finishedCount
-            console.log(`🔵 [PublishEvent] Relay finished`, { 
+            logger.debug(`[PublishEvent] Relay finished`, { 
               url, 
               finishedCount: currentFinished, 
               totalRelays: uniqueRelayUrls.length,
@@ -354,7 +354,7 @@ class ClientService extends EventTarget {
             }
             if (currentFinished >= uniqueRelayUrls.length && !hasResolved) {
               hasResolved = true
-              console.log('✅ [PublishEvent] All relays finished, resolving', {
+              logger.debug('[PublishEvent] All relays finished, resolving', {
                 success: successCount >= uniqueRelayUrls.length / 3,
                 successCount,
                 totalCount: uniqueRelayUrls.length,
@@ -376,7 +376,7 @@ class ClientService extends EventTarget {
               setTimeout(() => {
                 if (!hasResolved) {
                   hasResolved = true
-                  console.log('✅ [PublishEvent] Resolving early with enough successes', {
+                  logger.debug('[PublishEvent] Resolving early with enough successes', {
                     success: true,
                     successCount,
                     totalCount: uniqueRelayUrls.length,

src/services/indexed-db.service.ts

@@ -188,7 +188,7 @@ class IndexedDbService {
       return Promise.reject('store name not found')
     }
     
-    console.log('🔵 [IndexedDB] Putting replaceable event', {
+    logger.debug('[IndexedDB] Putting replaceable event', {
       kind: cleanEvent.kind,
       storeName,
       eventId: cleanEvent.id?.substring(0, 8),
@@ -225,7 +225,7 @@ class IndexedDbService {
       
       // Check if the store exists before trying to access it
       if (!this.db.objectStoreNames.contains(storeName)) {
-        console.error('[IndexedDB] Store not found in database after waiting', {
+        logger.error('[IndexedDB] Store not found in database after waiting', {
           storeName,
           kind: cleanEvent.kind,
           availableStores: Array.from(this.db.objectStoreNames),
@@ -240,7 +240,7 @@ class IndexedDbService {
         return resolve(cleanEvent)
       }
       
-      console.log('✅ [IndexedDB] Store exists, proceeding with save', {
+      logger.debug('[IndexedDB] Store exists, proceeding with save', {
         storeName,
         kind: cleanEvent.kind,
         eventId: cleanEvent.id?.substring(0, 8),
@@ -280,7 +280,7 @@ class IndexedDbService {
           return resolve(oldValue.value)
         }
         
-        console.log('🔵 [IndexedDB] Putting new event', { 
+        logger.debug('[IndexedDB] Putting new event', { 
           storeName, 
           key, 
           eventId: cleanEvent.id?.substring(0, 8), 
@@ -290,7 +290,7 @@ class IndexedDbService {
         logger.info('[IndexedDB] Putting new event', { storeName, key, eventId: cleanEvent.id?.substring(0, 8) })
         const putRequest = store.put(this.formatValue(key, cleanEvent))
         putRequest.onsuccess = () => {
-          console.log('✅ [IndexedDB] Successfully put event!', { 
+          logger.debug('[IndexedDB] Successfully put event!', { 
             storeName, 
             key, 
             eventId: cleanEvent.id?.substring(0, 8),
@@ -302,7 +302,7 @@ class IndexedDbService {
         }
 
         putRequest.onerror = (event) => {
-          console.error('❌ [IndexedDB] Error putting event!', { 
+          logger.error('[IndexedDB] Error putting event!', { 
             storeName, 
             key, 
             error: event,