Replace all logs with new logger

src/lib/analytics/analytics.tsx

···
 import {useStores} from 'state/models/root-store'
 import {sha256} from 'js-sha256'
 import {ScreenEvent, TrackEvent} from './types'
+import {logger} from '#/logger'
 
 const segmentClient = createClient({
   writeKey: '8I6DsgfiSLuoONyaunGoiQM7A6y2ybdI',
···
       if (sess.did) {
         const did_hashed = sha256(sess.did)
         segmentClient.identify(did_hashed, {did_hashed})
-        store.log.debug('Ping w/hash')
+        logger.debug('Ping w/hash')
       } else {
-        store.log.debug('Ping w/o hash')
+        logger.debug('Ping w/o hash')
         segmentClient.identify()
       }
     }
···
   // -prf
   segmentClient.isReady.onChange(() => {
     if (AppState.currentState !== 'active') {
-      store.log.debug('Prevented a metrics ping while the app was backgrounded')
+      logger.debug('Prevented a metrics ping while the app was backgrounded')
       return
     }
     const context = segmentClient.context.get()
     if (typeof context?.app === 'undefined') {
-      store.log.debug('Aborted metrics ping due to unavailable context')
+      logger.debug('Aborted metrics ping due to unavailable context')
       return
     }
 
     const oldAppInfo = store.appInfo
     const newAppInfo = context.app as AppInfo
     store.setAppInfo(newAppInfo)
-    store.log.debug('Recording app info', {new: newAppInfo, old: oldAppInfo})
+    logger.debug('Recording app info', {new: newAppInfo, old: oldAppInfo})
 
     if (typeof oldAppInfo === 'undefined') {
       if (store.session.hasSession) {

src/lib/analytics/analytics.web.tsx

···
 import {RootStoreModel} from 'state/models/root-store'
 import {useStores} from 'state/models/root-store'
 import {sha256} from 'js-sha256'
+import {logger} from '#/logger'
 
 const segmentClient = createClient(
   {
···
       if (sess.did) {
         const did_hashed = sha256(sess.did)
         segmentClient.identify(did_hashed, {did_hashed})
-        store.log.debug('Ping w/hash')
+        logger.debug('Ping w/hash')
       } else {
-        store.log.debug('Ping w/o hash')
+        logger.debug('Ping w/o hash')
         segmentClient.identify()
       }
     }

src/lib/api/index.ts

···
 import {isWeb} from 'platform/detection'
 import {ImageModel} from 'state/models/media/image'
 import {shortenLinks} from 'lib/strings/rich-text-manip'
+import {logger} from '#/logger'
 
 export interface ExternalEmbedDraft {
   uri: string
···
         ) {
           encoding = 'image/jpeg'
         } else {
-          store.log.warn('Unexpected image format for thumbnail, skipping', {
+          logger.warn('Unexpected image format for thumbnail, skipping', {
             thumbnail: opts.extLink.localThumb.path,
           })
         }

src/lib/hooks/useFollowProfile.ts

···
 import {AppBskyActorDefs} from '@atproto/api'
 import {useStores} from 'state/index'
 import {FollowState} from 'state/models/cache/my-follows'
+import {logger} from '#/logger'
 
 export function useFollowProfile(profile: AppBskyActorDefs.ProfileViewBasic) {
   const store = useStores()
···
             following: false,
           }
         } catch (e: any) {
-          store.log.error('Failed to delete follow', {error: e})
+          logger.error('Failed to delete follow', {error: e})
           throw e
         }
       } else if (state === FollowState.NotFollowing) {
···
             following: true,
           }
         } catch (e: any) {
-          store.log.error('Failed to create follow', {error: e})
+          logger.error('Failed to create follow', {error: e})
           throw e
         }
       }

src/lib/hooks/useOTAUpdate.ts

···
 import {useCallback, useEffect} from 'react'
 import {AppState} from 'react-native'
 import {useStores} from 'state/index'
+import {logger} from '#/logger'
 
 export function useOTAUpdate() {
   const store = useStores()
···
     })
   }, [store.shell])
   const checkForUpdate = useCallback(async () => {
-    store.log.debug('useOTAUpdate: Checking for update...')
+    logger.debug('useOTAUpdate: Checking for update...')
     try {
       // Check if new OTA update is available
       const update = await Updates.checkForUpdateAsync()
···
       // show a popup modal
       showUpdatePopup()
     } catch (e) {
-      store.log.error('useOTAUpdate: Error while checking for update', {
+      logger.error('useOTAUpdate: Error while checking for update', {
         error: e,
       })
     }
-  }, [showUpdatePopup, store.log])
+  }, [showUpdatePopup])
   const updateEventListener = useCallback(
     (event: Updates.UpdateEvent) => {
-      store.log.debug('useOTAUpdate: Listening for update...')
+      logger.debug('useOTAUpdate: Listening for update...')
       if (event.type === Updates.UpdateEventType.ERROR) {
-        store.log.error('useOTAUpdate: Error while listening for update', {
+        logger.error('useOTAUpdate: Error while listening for update', {
           message: event.message,
         })
       } else if (event.type === Updates.UpdateEventType.NO_UPDATE_AVAILABLE) {
···
         showUpdatePopup()
       }
     },
-    [showUpdatePopup, store.log],
+    [showUpdatePopup],
   )
 
   useEffect(() => {

src/lib/notifications/notifications.ts

···
 import {resetToTab} from '../../Navigation'
 import {devicePlatform, isIOS} from 'platform/detection'
 import {track} from 'lib/analytics/analytics'
+import {logger} from '#/logger'
 
 const SERVICE_DID = (serviceUrl?: string) =>
   serviceUrl?.includes('staging')
···
           token: token.data,
           appId: 'xyz.blueskyweb.app',
         })
-        store.log.debug('Notifications: Sent push token (init)', {
-          tokenType: token.type,
-          token: token.data,
-        })
+        logger.debug(
+          'Notifications: Sent push token (init)',
+          {
+            tokenType: token.type,
+            token: token.data,
+          },
+          logger.DebugContext.notifications,
+        )
       } catch (error) {
-        store.log.error('Notifications: Failed to set push token', {error})
+        logger.error('Notifications: Failed to set push token', {error})
       }
     }
 
     // listens for new changes to the push token
     // In rare situations, a push token may be changed by the push notification service while the app is running. When a token is rolled, the old one becomes invalid and sending notifications to it will fail. A push token listener will let you handle this situation gracefully by registering the new token with your backend right away.
     Notifications.addPushTokenListener(async ({data: t, type}) => {
-      store.log.debug('Notifications: Push token changed', {t, tokenType: type})
+      logger.debug(
+        'Notifications: Push token changed',
+        {t, tokenType: type},
+        logger.DebugContext.notifications,
+      )
       if (t) {
         try {
           await store.agent.api.app.bsky.notification.registerPush({
···
             token: t,
             appId: 'xyz.blueskyweb.app',
           })
-          store.log.debug('Notifications: Sent push token (event)', {
-            tokenType: type,
-            token: t,
-          })
+          logger.debug(
+            'Notifications: Sent push token (event)',
+            {
+              tokenType: type,
+              token: t,
+            },
+            logger.DebugContext.notifications,
+          )
         } catch (error) {
-          store.log.error('Notifications: Failed to set push token', {error})
+          logger.error('Notifications: Failed to set push token', {error})
         }
       }
     })
···
 
   // handle notifications that are received, both in the foreground or background
   Notifications.addNotificationReceivedListener(event => {
-    store.log.debug('Notifications: received', {event})
+    logger.debug(
+      'Notifications: received',
+      {event},
+      logger.DebugContext.notifications,
+    )
     if (event.request.trigger.type === 'push') {
       // refresh notifications in the background
       store.me.notifications.syncQueue()
···
         // TODO: handle android payload deeplink
       }
       if (payload) {
-        store.log.debug('Notifications: received payload', payload)
+        logger.debug(
+          'Notifications: received payload',
+          payload,
+          logger.DebugContext.notifications,
+        )
         // TODO: deeplink notif here
       }
     }
···
   // handle notifications that are tapped on
   const sub = Notifications.addNotificationResponseReceivedListener(
     response => {
-      store.log.debug('Notifications: response received', {
-        actionIdentifier: response.actionIdentifier,
-      })
+      logger.debug(
+        'Notifications: response received',
+        {
+          actionIdentifier: response.actionIdentifier,
+        },
+        logger.DebugContext.notifications,
+      )
       if (
         response.actionIdentifier === Notifications.DEFAULT_ACTION_IDENTIFIER
       ) {
-        store.log.debug(
+        logger.debug(
           'User pressed a notification, opening notifications tab',
+          {},
+          logger.DebugContext.notifications,
         )
         track('Notificatons:OpenApp')
         store.me.notifications.refresh() // refresh notifications

src/logger/debugContext.ts

···
  */
 export const DebugContext = {
   // e.g. composer: 'composer'
+  session: 'session',
+  notifications: 'notifications',
 } as const

src/state/index.ts

···
 import {RootStoreModel} from './models/root-store'
 import * as apiPolyfill from 'lib/api/api-polyfill'
 import * as storage from 'lib/storage'
+import {logger} from '#/logger'
 
 export const LOCAL_DEV_SERVICE =
   Platform.OS === 'android' ? 'http://10.0.2.2:2583' : 'http://localhost:2583'
···
   rootStore = new RootStoreModel(new BskyAgent({service: serviceUri}))
   try {
     data = (await storage.load(ROOT_STATE_STORAGE_KEY)) || {}
-    rootStore.log.debug('Initial hydrate', {hasSession: !!data.session})
+    logger.debug('Initial hydrate', {hasSession: !!data.session})
     rootStore.hydrate(data)
   } catch (e: any) {
-    rootStore.log.error('Failed to load state from storage', {error: e})
+    logger.error('Failed to load state from storage', {error: e})
   }
   rootStore.attemptSessionResumption()
 

src/state/models/content/feed-source.ts

···
 import {bundleAsync} from 'lib/async/bundle'
 import {cleanError} from 'lib/strings/errors'
 import {track} from 'lib/analytics/analytics'
+import {logger} from '#/logger'
 
 export class FeedSourceModel {
   // state
···
     try {
       await this.rootStore.preferences.addSavedFeed(this.uri)
     } catch (error) {
-      this.rootStore.log.error('Failed to save feed', {error})
+      logger.error('Failed to save feed', {error})
     } finally {
       track('CustomFeed:Save')
     }
···
     try {
       await this.rootStore.preferences.removeSavedFeed(this.uri)
     } catch (error) {
-      this.rootStore.log.error('Failed to unsave feed', {error})
+      logger.error('Failed to unsave feed', {error})
     } finally {
       track('CustomFeed:Unsave')
     }
···
     try {
       await this.rootStore.preferences.addPinnedFeed(this.uri)
     } catch (error) {
-      this.rootStore.log.error('Failed to pin feed', {error})
+      logger.error('Failed to pin feed', {error})
     } finally {
       track('CustomFeed:Pin', {
         name: this.displayName,
···
     } catch (e: any) {
       this.likeUri = undefined
       this.likeCount = (this.likeCount || 1) - 1
-      this.rootStore.log.error('Failed to like feed', {error: e})
+      logger.error('Failed to like feed', {error: e})
     } finally {
       track('CustomFeed:Like')
     }
···
     } catch (e: any) {
       this.likeUri = uri
       this.likeCount = (this.likeCount || 0) + 1
-      this.rootStore.log.error('Failed to unlike feed', {error: e})
+      logger.error('Failed to unlike feed', {error: e})
     } finally {
       track('CustomFeed:Unlike')
     }

src/state/models/content/list.ts

···
 import {bundleAsync} from 'lib/async/bundle'
 import {track} from 'lib/analytics/analytics'
 import {until} from 'lib/async/until'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     try {
       await this.rootStore.preferences.addPinnedFeed(this.uri)
     } catch (error) {
-      this.rootStore.log.error('Failed to pin feed', {error})
+      logger.error('Failed to pin feed', {error})
     } finally {
       track('CustomFeed:Pin', {
         name: this.data?.name || '',
···
     this.error = cleanError(err)
     this.loadMoreError = cleanError(loadMoreErr)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user items', {error: err})
+      logger.error('Failed to fetch user items', {error: err})
     }
     if (loadMoreErr) {
-      this.rootStore.log.error('Failed to fetch user items', {
+      logger.error('Failed to fetch user items', {
         error: loadMoreErr,
       })
     }

src/state/models/content/post-thread.ts

···
 import {cleanError} from 'lib/strings/errors'
 import {ThreadViewPreference} from '../ui/preferences'
 import {PostThreadItemModel} from './post-thread-item'
+import {logger} from '#/logger'
 
 export class PostThreadModel {
   // state
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch post thread', {error: err})
+      logger.error('Failed to fetch post thread', {error: err})
     }
     this.notFound = err instanceof GetPostThread.NotFoundError
   }

src/state/models/content/profile.ts

···
 import {FollowState} from '../cache/my-follows'
 import {Image as RNImage} from 'react-native-image-crop-picker'
 import {track} from 'lib/analytics/analytics'
+import {logger} from '#/logger'
 
 export class ProfileViewerModel {
   muted?: boolean
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch profile', {error: err})
+      logger.error('Failed to fetch profile', {error: err})
     }
   }
 

src/state/models/discovery/feeds.ts

···
 import {bundleAsync} from 'lib/async/bundle'
 import {cleanError} from 'lib/strings/errors'
 import {FeedSourceModel} from '../content/feed-source'
+import {logger} from '#/logger'
 
 const DEFAULT_LIMIT = 50
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch popular feeds', {error: err})
+      logger.error('Failed to fetch popular feeds', {error: err})
     }
   }
 

src/state/models/discovery/suggested-actors.ts

···
 import {RootStoreModel} from '../root-store'
 import {cleanError} from 'lib/strings/errors'
 import {bundleAsync} from 'lib/async/bundle'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch suggested actors', {error: err})
+      logger.error('Failed to fetch suggested actors', {error: err})
     }
   }
 }

src/state/models/feeds/notifications.ts

···
 import {RootStoreModel} from '../root-store'
 import {PostThreadModel} from '../content/post-thread'
 import {cleanError} from 'lib/strings/errors'
+import {logger} from '#/logger'
 
 const GROUPABLE_REASONS = ['like', 'repost', 'follow']
 const PAGE_SIZE = 30
···
         if (valid.success) {
           return v
         } else {
-          this.rootStore.log.warn('Received an invalid record', {
+          logger.warn('Received an invalid record', {
             record: v,
             error: valid.error,
           })
···
         }
       }
     }
-    this.rootStore.log.warn(
+    logger.warn(
       'app.bsky.notifications.list served an unsupported record type',
       {record: v},
     )
···
    * Nuke all data
    */
   clear() {
-    this.rootStore.log.debug('NotificationsModel:clear')
+    logger.debug('NotificationsModel:clear')
     this.isLoading = false
     this.isRefreshing = false
     this.hasLoaded = false
···
    * Load for first render
    */
   setup = bundleAsync(async (isRefreshing: boolean = false) => {
-    this.rootStore.log.debug('NotificationsModel:refresh', {isRefreshing})
+    logger.debug('NotificationsModel:refresh', {isRefreshing})
     await this.lock.acquireAsync()
     try {
       this._xLoading(isRefreshing)
···
    * Sync the next set of notifications to show
    */
   syncQueue = bundleAsync(async () => {
-    this.rootStore.log.debug('NotificationsModel:syncQueue')
+    logger.debug('NotificationsModel:syncQueue')
     if (this.unreadCount >= MAX_VISIBLE_NOTIFS) {
       return // no need to check
     }
···
       this._setQueued(this._filterNotifications(queueModels))
       this._countUnread()
     } catch (e) {
-      this.rootStore.log.error('NotificationsModel:syncQueue failed', {
+      logger.error('NotificationsModel:syncQueue failed', {
         error: e,
       })
     } finally {
···
       }
     }
     await Promise.all(promises).catch(e => {
-      this.rootStore.log.error(
-        'Uncaught failure during notifications update()',
-        e,
-      )
+      logger.error('Uncaught failure during notifications update()', e)
     })
   }
 
···
         this.lastSync ? this.lastSync.toISOString() : undefined,
       )
     } catch (e: any) {
-      this.rootStore.log.warn('Failed to update notifications read state', {
+      logger.warn('Failed to update notifications read state', {
         error: e,
       })
     }
···
     this.error = cleanError(error)
     this.loadMoreError = cleanError(loadMoreError)
     if (error) {
-      this.rootStore.log.error('Failed to fetch notifications', {error})
+      logger.error('Failed to fetch notifications', {error})
     }
     if (loadMoreError) {
-      this.rootStore.log.error('Failed to load more notifications', {
+      logger.error('Failed to load more notifications', {
         error: loadMoreError,
       })
     }

src/state/models/feeds/post.ts

···
 import {updateDataOptimistically} from 'lib/async/revertible'
 import {track} from 'lib/analytics/analytics'
 import {hackAddDeletedEmbed} from 'lib/api/hack-add-deleted-embed'
+import {logger} from '#/logger'
 
 type FeedViewPost = AppBskyFeedDefs.FeedViewPost
 type ReasonRepost = AppBskyFeedDefs.ReasonRepost
···
       } else {
         this.postRecord = undefined
         this.richText = undefined
-        rootStore.log.warn('Received an invalid app.bsky.feed.post record', {
+        logger.warn('Received an invalid app.bsky.feed.post record', {
           error: valid.error,
         })
       }
     } else {
       this.postRecord = undefined
       this.richText = undefined
-      rootStore.log.warn(
+      logger.warn(
         'app.bsky.feed.getTimeline or app.bsky.feed.getAuthorFeed served an unexpected record type',
         {record: this.post.record},
       )
···
         track('Post:Like')
       }
     } catch (error) {
-      this.rootStore.log.error('Failed to toggle like', {error})
+      logger.error('Failed to toggle like', {error})
     }
   }
 
···
         track('Post:Repost')
       }
     } catch (error) {
-      this.rootStore.log.error('Failed to toggle repost', {error})
+      logger.error('Failed to toggle repost', {error})
     }
   }
 
···
         track('Post:ThreadMute')
       }
     } catch (error) {
-      this.rootStore.log.error('Failed to toggle thread mute', {error})
+      logger.error('Failed to toggle thread mute', {error})
     }
   }
 
···
       await this.rootStore.agent.deletePost(this.post.uri)
       this.rootStore.emitPostDeleted(this.post.uri)
     } catch (error) {
-      this.rootStore.log.error('Failed to delete post', {error})
+      logger.error('Failed to delete post', {error})
     } finally {
       track('Post:Delete')
     }

src/state/models/feeds/posts.ts

···
 import {CustomFeedAPI} from 'lib/api/feed/custom'
 import {ListFeedAPI} from 'lib/api/feed/list'
 import {MergeFeedAPI} from 'lib/api/feed/merge'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
    * Nuke all data
    */
   clear() {
-    this.rootStore.log.debug('FeedModel:clear')
+    logger.debug('FeedModel:clear')
     this.isLoading = false
     this.isRefreshing = false
     this.hasNewLatest = false
···
    * Load for first render
    */
   setup = bundleAsync(async (isRefreshing: boolean = false) => {
-    this.rootStore.log.debug('FeedModel:setup', {isRefreshing})
+    logger.debug('FeedModel:setup', {isRefreshing})
     if (isRefreshing) {
       this.isRefreshing = true // set optimistically for UI
     }
···
     this.knownError = detectKnownError(this.feedType, error)
     this.loadMoreError = cleanError(loadMoreError)
     if (error) {
-      this.rootStore.log.error('Posts feed request failed', {error})
+      logger.error('Posts feed request failed', {error})
     }
     if (loadMoreError) {
-      this.rootStore.log.error('Posts feed load-more request failed', {
+      logger.error('Posts feed load-more request failed', {
         error: loadMoreError,
       })
     }

src/state/models/invited-users.ts

···
 import {ComAtprotoServerDefs, AppBskyActorDefs} from '@atproto/api'
 import {RootStoreModel} from './root-store'
 import {isObj, hasProp, isStrArray} from 'lib/type-guards'
+import {logger} from '#/logger'
 
 export class InvitedUsers {
   copiedInvites: string[] = []
···
         })
         this.rootStore.me.follows.hydrateMany(this.profiles)
       } catch (e) {
-        this.rootStore.log.error('Failed to fetch profiles for invited users', {
+        logger.error('Failed to fetch profiles for invited users', {
           error: e,
         })
       }

src/state/models/lists/actor-feeds.ts

···
 import {bundleAsync} from 'lib/async/bundle'
 import {cleanError} from 'lib/strings/errors'
 import {FeedSourceModel} from '../content/feed-source'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user followers', {error: err})
+      logger.error('Failed to fetch user followers', {error: err})
     }
   }
 

src/state/models/lists/blocked-accounts.ts

···
 import {RootStoreModel} from '../root-store'
 import {cleanError} from 'lib/strings/errors'
 import {bundleAsync} from 'lib/async/bundle'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user followers', {error: err})
+      logger.error('Failed to fetch user followers', {error: err})
     }
   }
 

src/state/models/lists/likes.ts

···
 import {cleanError} from 'lib/strings/errors'
 import {bundleAsync} from 'lib/async/bundle'
 import * as apilib from 'lib/api/index'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch likes', {error: err})
+      logger.error('Failed to fetch likes', {error: err})
     }
   }
 

src/state/models/lists/lists-list.ts

···
 import {cleanError} from 'lib/strings/errors'
 import {bundleAsync} from 'lib/async/bundle'
 import {accumulate} from 'lib/async/accumulate'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.error = cleanError(err)
     this.loadMoreError = cleanError(loadMoreErr)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user lists', {error: err})
+      logger.error('Failed to fetch user lists', {error: err})
     }
     if (loadMoreErr) {
-      this.rootStore.log.error('Failed to fetch user lists', {
+      logger.error('Failed to fetch user lists', {
         error: loadMoreErr,
       })
     }

src/state/models/lists/muted-accounts.ts

···
 import {RootStoreModel} from '../root-store'
 import {cleanError} from 'lib/strings/errors'
 import {bundleAsync} from 'lib/async/bundle'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user followers', {error: err})
+      logger.error('Failed to fetch user followers', {error: err})
     }
   }
 

src/state/models/lists/reposted-by.ts

···
 import {bundleAsync} from 'lib/async/bundle'
 import {cleanError} from 'lib/strings/errors'
 import * as apilib from 'lib/api/index'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch reposted by view', {error: err})
+      logger.error('Failed to fetch reposted by view', {error: err})
     }
   }
 

src/state/models/lists/user-followers.ts

···
 import {RootStoreModel} from '../root-store'
 import {cleanError} from 'lib/strings/errors'
 import {bundleAsync} from 'lib/async/bundle'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user followers', {error: err})
+      logger.error('Failed to fetch user followers', {error: err})
     }
   }
 

src/state/models/lists/user-follows.ts

···
 import {RootStoreModel} from '../root-store'
 import {cleanError} from 'lib/strings/errors'
 import {bundleAsync} from 'lib/async/bundle'
+import {logger} from '#/logger'
 
 const PAGE_SIZE = 30
 
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user follows', err)
+      logger.error('Failed to fetch user follows', err)
     }
   }
 

src/state/models/me.ts

···
 import {MyFeedsUIModel} from './ui/my-feeds'
 import {MyFollowsCache} from './cache/my-follows'
 import {isObj, hasProp} from 'lib/type-guards'
+import {logger} from '#/logger'
 
 const PROFILE_UPDATE_INTERVAL = 10 * 60 * 1e3 // 10min
 const NOTIFS_UPDATE_INTERVAL = 30 * 1e3 // 30sec
···
 
   async load() {
     const sess = this.rootStore.session
-    this.rootStore.log.debug('MeModel:load', {hasSession: sess.hasSession})
+    logger.debug('MeModel:load', {hasSession: sess.hasSession})
     if (sess.hasSession) {
       this.did = sess.currentSession?.did || ''
       await this.fetchProfile()
       this.mainFeed.clear()
       /* dont await */ this.mainFeed.setup().catch(e => {
-        this.rootStore.log.error('Failed to setup main feed model', {error: e})
+        logger.error('Failed to setup main feed model', {error: e})
       })
       /* dont await */ this.notifications.setup().catch(e => {
-        this.rootStore.log.error('Failed to setup notifications model', {
+        logger.error('Failed to setup notifications model', {
           error: e,
         })
       })
       /* dont await */ this.notifications.setup().catch(e => {
-        this.rootStore.log.error('Failed to setup notifications model', {
+        logger.error('Failed to setup notifications model', {
           error: e,
         })
       })
···
 
   async updateIfNeeded() {
     if (Date.now() - this.lastProfileStateUpdate > PROFILE_UPDATE_INTERVAL) {
-      this.rootStore.log.debug('Updating me profile information')
+      logger.debug('Updating me profile information')
       this.lastProfileStateUpdate = Date.now()
       await this.fetchProfile()
       await this.fetchInviteCodes()
···
           })
         })
       } catch (e) {
-        this.rootStore.log.error('Failed to fetch user invite codes', {
+        logger.error('Failed to fetch user invite codes', {
           error: e,
         })
       }
···
           this.appPasswords = res.data.passwords
         })
       } catch (e) {
-        this.rootStore.log.error('Failed to fetch user app passwords', {
+        logger.error('Failed to fetch user app passwords', {
           error: e,
         })
       }
···
         })
         return res.data
       } catch (e) {
-        this.rootStore.log.error('Failed to create app password', {error: e})
+        logger.error('Failed to create app password', {error: e})
       }
     }
   }
···
           this.appPasswords = this.appPasswords.filter(p => p.name !== name)
         })
       } catch (e) {
-        this.rootStore.log.error('Failed to delete app password', {error: e})
+        logger.error('Failed to delete app password', {error: e})
       }
     }
   }

src/state/models/media/image.ts

···
 import {Position} from 'react-avatar-editor'
 import {Dimensions} from 'lib/media/types'
 import {isIOS} from 'platform/detection'
+import {logger} from '#/logger'
 
 export interface ImageManipulationAttributes {
   aspectRatio?: '4:3' | '1:1' | '3:4' | 'None'
···
         this.cropped = cropped
       })
     } catch (err) {
-      this.rootStore.log.error('Failed to crop photo', {error: err})
+      logger.error('Failed to crop photo', {error: err})
     }
   }
 

src/state/models/root-store.ts

···
 export class RootStoreModel {
   agent: BskyAgent
   appInfo?: AppInfo
-  log = logger
   session = new SessionModel(this)
   shell = new ShellUiModel(this)
   preferences = new PreferencesModel(this)
···
    * Called during init to resume any stored session.
    */
   async attemptSessionResumption() {
-    this.log.debug('RootStoreModel:attemptSessionResumption')
+    logger.debug('RootStoreModel:attemptSessionResumption')
     try {
       await this.session.attemptSessionResumption()
-      this.log.debug('Session initialized', {
+      logger.debug('Session initialized', {
         hasSession: this.session.hasSession,
       })
       this.updateSessionState()
     } catch (e: any) {
-      this.log.warn('Failed to initialize session', {error: e})
+      logger.warn('Failed to initialize session', {error: e})
     }
   }
 
···
     agent: BskyAgent,
     {hadSession}: {hadSession: boolean},
   ) {
-    this.log.debug('RootStoreModel:handleSessionChange')
+    logger.debug('RootStoreModel:handleSessionChange')
     this.agent = agent
     applyDebugHeader(this.agent)
     this.me.clear()
···
    * Called by the session model. Handles session drops by informing the user.
    */
   async handleSessionDrop() {
-    this.log.debug('RootStoreModel:handleSessionDrop')
+    logger.debug('RootStoreModel:handleSessionDrop')
     resetToTab('HomeTab')
     this.me.clear()
     this.emitSessionDropped()
···
    * Clears all session-oriented state.
    */
   clearAllSessionState() {
-    this.log.debug('RootStoreModel:clearAllSessionState')
+    logger.debug('RootStoreModel:clearAllSessionState')
     this.session.clear()
     resetToTab('HomeTab')
     this.me.clear()
···
       await this.me.updateIfNeeded()
       await this.preferences.sync()
     } catch (e: any) {
-      this.log.error('Failed to fetch latest state', {error: e})
+      logger.error('Failed to fetch latest state', {error: e})
     }
   }
 

src/state/models/session.ts

···
 import {RootStoreModel} from './root-store'
 import {IS_PROD} from 'lib/constants'
 import {track} from 'lib/analytics/analytics'
+import {logger} from '#/logger'
 
 export type ServiceDescription = DescribeServer.OutputSchema
 
···
       ),
       isResumingSession: this.isResumingSession,
     }
-    this.rootStore.log.debug(message, details)
+    logger.debug(message, details, logger.DebugContext.session)
   }
 
   /**

src/state/models/ui/create-account.ts

···
 import {cleanError} from 'lib/strings/errors'
 import {getAge} from 'lib/strings/time'
 import {track} from 'lib/analytics/analytics'
+import {logger} from '#/logger'
 
 const DEFAULT_DATE = new Date(Date.now() - 60e3 * 60 * 24 * 365 * 20) // default to 20 years ago
 
···
       this.setServiceDescription(desc)
       this.setUserDomain(desc.availableUserDomains[0])
     } catch (err: any) {
-      this.rootStore.log.warn(
+      logger.warn(
         `Failed to fetch service description for ${this.serviceUrl}`,
         {error: err},
       )
···
         errMsg =
           'Invite code not accepted. Check that you input it correctly and try again.'
       }
-      this.rootStore.log.error('Failed to create account', {error: e})
+      logger.error('Failed to create account', {error: e})
       this.setIsProcessing(false)
       this.setError(cleanError(errMsg))
       throw e

src/state/models/ui/preferences.ts

···
 import {getAge} from 'lib/strings/time'
 import {FeedTuner} from 'lib/api/feed-manip'
 import {LANGUAGES} from '../../../locale/languages'
+import {logger} from '#/logger'
 
 // TEMP we need to permanently convert 'show' to 'ignore', for now we manually convert -prf
 export type LabelPreference = APILabelPreference | 'show'
···
           })
           await this.rootStore.agent.setSavedFeeds(saved, pinned)
         } catch (error) {
-          this.rootStore.log.error('Failed to set default feeds', {error})
+          logger.error('Failed to set default feeds', {error})
         }
       }
     } finally {

src/state/models/ui/profile.ts

···
 import {PostsFeedModel} from '../feeds/posts'
 import {ActorFeedsModel} from '../lists/actor-feeds'
 import {ListsListModel} from '../lists/lists-list'
+import {logger} from '#/logger'
 
 export enum Sections {
   PostsNoReplies = 'Posts',
···
     await Promise.all([
       this.profile
         .setup()
-        .catch(err =>
-          this.rootStore.log.error('Failed to fetch profile', {error: err}),
-        ),
+        .catch(err => logger.error('Failed to fetch profile', {error: err})),
       this.feed
         .setup()
-        .catch(err =>
-          this.rootStore.log.error('Failed to fetch feed', {error: err}),
-        ),
+        .catch(err => logger.error('Failed to fetch feed', {error: err})),
     ])
     runInAction(() => {
       this.isAuthenticatedUser =
···
     this.lists.source = this.profile.did
     this.lists
       .loadMore()
-      .catch(err =>
-        this.rootStore.log.error('Failed to fetch lists', {error: err}),
-      )
+      .catch(err => logger.error('Failed to fetch lists', {error: err}))
   }
 
   async refresh() {

src/state/models/ui/saved-feeds.ts

···
 import {cleanError} from 'lib/strings/errors'
 import {FeedSourceModel} from '../content/feed-source'
 import {track} from 'lib/analytics/analytics'
+import {logger} from '#/logger'
 
 export class SavedFeedsModel {
   // state
···
     this.hasLoaded = true
     this.error = cleanError(err)
     if (err) {
-      this.rootStore.log.error('Failed to fetch user feeds', {err})
+      logger.error('Failed to fetch user feeds', {err})
     }
   }
 

src/view/com/auth/login/Login.tsx

···
 import {useTheme} from 'lib/ThemeContext'
 import {cleanError} from 'lib/strings/errors'
 import {isWeb} from 'platform/detection'
+import {logger} from '#/logger'
 
 enum Forms {
   Login,
···
         if (aborted) {
           return
         }
-        store.log.warn(
-          `Failed to fetch service description for ${serviceUrl}`,
-          {error: err},
-        )
+        logger.warn(`Failed to fetch service description for ${serviceUrl}`, {
+          error: err,
+        })
         setError(
           'Unable to contact your service. Please check your Internet connection.',
         )
···
     return () => {
       aborted = true
     }
-  }, [store.session, store.log, serviceUrl, retryDescribeTrigger])
+  }, [store.session, serviceUrl, retryDescribeTrigger])
 
   const onPressRetryConnect = () => setRetryDescribeTrigger({})
   const onPressForgotPassword = () => {
···
       })
     } catch (e: any) {
       const errMsg = e.toString()
-      store.log.warn('Failed to login', {error: e})
+      logger.warn('Failed to login', {error: e})
       setIsProcessing(false)
       if (errMsg.includes('Authentication Required')) {
         setError('Invalid username or password')
···
       onEmailSent()
     } catch (e: any) {
       const errMsg = e.toString()
-      store.log.warn('Failed to request password reset', {error: e})
+      logger.warn('Failed to request password reset', {error: e})
       setIsProcessing(false)
       if (isNetworkError(e)) {
         setError(
···
 }
 
 const SetNewPasswordForm = ({
-  store,
   error,
   serviceUrl,
   setError,
···
       onPasswordSet()
     } catch (e: any) {
       const errMsg = e.toString()
-      store.log.warn('Failed to set new password', {error: e})
+      logger.warn('Failed to set new password', {error: e})
       setIsProcessing(false)
       if (isNetworkError(e)) {
         setError(

src/view/com/composer/photos/OpenCameraBtn.tsx

···
 import {HITSLOP_10, POST_IMG_MAX} from 'lib/constants'
 import {GalleryModel} from 'state/models/media/gallery'
 import {isMobileWeb, isNative} from 'platform/detection'
+import {logger} from '#/logger'
 
 type Props = {
   gallery: GalleryModel
···
       gallery.add(img)
     } catch (err: any) {
       // ignore
-      store.log.warn('Error using camera', {error: err})
+      logger.warn('Error using camera', {error: err})
     }
   }, [gallery, track, store, requestCameraAccessIfNeeded])
 

src/view/com/composer/useExternalLinkFetch.ts

···
 } from 'lib/strings/url-helpers'
 import {ComposerOpts} from 'state/models/ui/shell'
 import {POST_IMG_MAX} from 'lib/constants'
+import {logger} from '#/logger'
 
 export function useExternalLinkFetch({
   setQuote,
···
             setExtLink(undefined)
           },
           err => {
-            store.log.error('Failed to fetch post for quote embedding', {
+            logger.error('Failed to fetch post for quote embedding', {
               error: err,
             })
             setExtLink(undefined)
···
             })
           },
           err => {
-            store.log.error('Failed to fetch feed for embedding', {error: err})
+            logger.error('Failed to fetch feed for embedding', {error: err})
             setExtLink(undefined)
           },
         )
···
             })
           },
           err => {
-            store.log.error('Failed to fetch list for embedding', {error: err})
+            logger.error('Failed to fetch list for embedding', {error: err})
             setExtLink(undefined)
           },
         )

src/view/com/feeds/FeedPage.tsx

···
 import {FAB} from '../util/fab/FAB'
 import {LoadLatestBtn} from '../util/load-latest/LoadLatestBtn'
 import useAppState from 'react-native-appstate-hook'
+import {logger} from '#/logger'
 
 export const FeedPage = observer(function FeedPageImpl({
   testID,
···
       if (feed.isLoading) {
         return
       }
-      store.log.debug('HomeScreen: Polling for new posts')
+      logger.debug('HomeScreen: Polling for new posts')
       feed.checkForLatest()
     },
-    [appState, isScreenFocused, isPageFocused, store, feed],
+    [appState, isScreenFocused, isPageFocused, feed],
   )
 
   const scrollToTop = React.useCallback(() => {
···
     const pollInterval = setInterval(doPoll, POLL_FREQ)
 
     screen('Feed')
-    store.log.debug('HomeScreen: Updating feed')
+    logger.debug('HomeScreen: Updating feed')
     feed.checkForLatest()
 
     return () => {

src/view/com/feeds/FeedSourceCard.tsx

···
 import {AtUri} from '@atproto/api'
 import * as Toast from 'view/com/util/Toast'
 import {sanitizeHandle} from 'lib/strings/handles'
+import {logger} from '#/logger'
 
 export const FeedSourceCard = observer(function FeedSourceCardImpl({
   item,
···
             Toast.show('Removed from my feeds')
           } catch (e) {
             Toast.show('There was an issue contacting your server')
-            store.log.error('Failed to unsave feed', {error: e})
+            logger.error('Failed to unsave feed', {error: e})
           }
         },
       })
···
         Toast.show('Added to my feeds')
       } catch (e) {
         Toast.show('There was an issue contacting your server')
-        store.log.error('Failed to save feed', {error: e})
+        logger.error('Failed to save feed', {error: e})
       }
     }
   }, [store, item])

src/view/com/lists/ListItems.tsx

···
 import {useWebMediaQueries} from 'lib/hooks/useWebMediaQueries'
 import {s} from 'lib/styles'
 import {OnScrollCb} from 'lib/hooks/useOnMainScroll'
+import {logger} from '#/logger'
 
 const LOADING_ITEM = {_reactKey: '__loading__'}
 const EMPTY_ITEM = {_reactKey: '__empty__'}
···
     try {
       await list.refresh()
     } catch (err) {
-      list.rootStore.log.error('Failed to refresh lists', {error: err})
+      logger.error('Failed to refresh lists', {error: err})
     }
     setIsRefreshing(false)
   }, [list, track, setIsRefreshing])
···
     try {
       await list.loadMore()
     } catch (err) {
-      list.rootStore.log.error('Failed to load more lists', {error: err})
+      logger.error('Failed to load more lists', {error: err})
     }
   }, [list, track])
 

src/view/com/lists/ListsList.tsx

···
 import {usePalette} from 'lib/hooks/usePalette'
 import {FlatList} from '../util/Views.web'
 import {s} from 'lib/styles'
+import {logger} from '#/logger'
 
 const LOADING = {_reactKey: '__loading__'}
 const EMPTY = {_reactKey: '__empty__'}
···
     try {
       await listsList.refresh()
     } catch (err) {
-      listsList.rootStore.log.error('Failed to refresh lists', {error: err})
+      logger.error('Failed to refresh lists', {error: err})
     }
     setIsRefreshing(false)
   }, [listsList, track, setIsRefreshing])
···
     try {
       await listsList.loadMore()
     } catch (err) {
-      listsList.rootStore.log.error('Failed to load more lists', {error: err})
+      logger.error('Failed to load more lists', {error: err})
     }
   }, [listsList, track])
 

src/view/com/modals/AddAppPasswords.tsx

···
 } from '@fortawesome/react-native-fontawesome'
 import Clipboard from '@react-native-clipboard/clipboard'
 import * as Toast from '../util/Toast'
+import {logger} from '#/logger'
 
 export const snapPoints = ['70%']
 
···
       }
     } catch (e) {
       Toast.show('Failed to create app password.')
-      store.log.error('Failed to create app password', {error: e})
+      logger.error('Failed to create app password', {error: e})
     }
   }
 

src/view/com/modals/ChangeHandle.tsx

···
 import {useTheme} from 'lib/ThemeContext'
 import {useAnalytics} from 'lib/analytics/analytics'
 import {cleanError} from 'lib/strings/errors'
+import {logger} from '#/logger'
 
 export const snapPoints = ['100%']
 
···
           return
         }
         setProcessing(false)
-        store.log.warn(
+        logger.warn(
           `Failed to fetch service description for ${String(
             store.agent.service,
           )}`,
···
     return () => {
       aborted = true
     }
-  }, [store.agent.service, store.session, store.log, retryDescribeTrigger])
+  }, [store.agent.service, store.session, retryDescribeTrigger])
 
   // events
   // =
···
     try {
       track('EditHandle:SetNewHandle')
       const newHandle = isCustom ? handle : createFullHandle(handle, userDomain)
-      store.log.debug(`Updating handle to ${newHandle}`)
+      logger.debug(`Updating handle to ${newHandle}`)
       await store.agent.updateHandle({
         handle: newHandle,
       })
···
       onChanged()
     } catch (err: any) {
       setError(cleanError(err))
-      store.log.error('Failed to update handle', {handle, error: err})
+      logger.error('Failed to update handle', {handle, error: err})
     } finally {
       setProcessing(false)
     }
···
       }
     } catch (err: any) {
       setError(cleanError(err))
-      store.log.error('Failed to verify domain', {handle, error: err})
+      logger.error('Failed to verify domain', {handle, error: err})
     } finally {
       setIsVerifying(false)
     }
···
     setError,
     canSave,
     onPressSave,
-    store.log,
     store.agent,
   ])
 

src/view/com/modals/ContentFilteringSettings.tsx

···
 import {isIOS} from 'platform/detection'
 import {useWebMediaQueries} from 'lib/hooks/useWebMediaQueries'
 import * as Toast from '../util/Toast'
+import {logger} from '#/logger'
 
 export const snapPoints = ['90%']
 
···
         Toast.show(
           'There was an issue syncing your preferences with the server',
         )
-        store.log.error('Failed to update preferences with server', {error: e})
+        logger.error('Failed to update preferences with server', {error: e})
       }
     }
 
···
         Toast.show(
           'There was an issue syncing your preferences with the server',
         )
-        store.log.error('Failed to update preferences with server', {error: e})
+        logger.error('Failed to update preferences with server', {error: e})
       }
     },
     [store, group],

src/view/com/modals/UserAddRemoveLists.tsx

···
 import {usePalette} from 'lib/hooks/usePalette'
 import {isWeb, isAndroid} from 'platform/detection'
 import isEqual from 'lodash.isequal'
+import {logger} from '#/logger'
 
 export const snapPoints = ['fullscreen']
 
···
         setMembershipsLoaded(true)
       },
       err => {
-        store.log.error('Failed to fetch memberships', {error: err})
+        logger.error('Failed to fetch memberships', {error: err})
       },
     )
   }, [memberships, listsList, store, setSelected, setMembershipsLoaded])
···
     try {
       changes = await memberships.updateTo(selected)
     } catch (err) {
-      store.log.error('Failed to update memberships', {error: err})
+      logger.error('Failed to update memberships', {error: err})
       return
     }
     Toast.show('Lists updated')

src/view/com/notifications/Feed.tsx

···
 import {OnScrollCb} from 'lib/hooks/useOnMainScroll'
 import {s} from 'lib/styles'
 import {usePalette} from 'lib/hooks/usePalette'
+import {logger} from '#/logger'
 
 const EMPTY_FEED_ITEM = {_reactKey: '__empty__'}
 const LOAD_MORE_ERROR_ITEM = {_reactKey: '__load_more_error__'}
···
       setIsPTRing(true)
       await view.refresh()
     } catch (err) {
-      view.rootStore.log.error('Failed to refresh notifications feed', {
+      logger.error('Failed to refresh notifications feed', {
         error: err,
       })
     } finally {
···
     try {
       await view.loadMore()
     } catch (err) {
-      view.rootStore.log.error('Failed to load more notifications', {
+      logger.error('Failed to load more notifications', {
         error: err,
       })
     }

src/view/com/post-thread/PostLikedBy.tsx

···
 import {ProfileCardWithFollowBtn} from '../profile/ProfileCard'
 import {useStores} from 'state/index'
 import {usePalette} from 'lib/hooks/usePalette'
+import {logger} from '#/logger'
 
 export const PostLikedBy = observer(function PostLikedByImpl({
   uri,
···
   useEffect(() => {
     view
       .loadMore()
-      .catch(err => store.log.error('Failed to fetch likes', {error: err}))
-  }, [view, store.log])
+      .catch(err => logger.error('Failed to fetch likes', {error: err}))
+  }, [view])
 
   const onRefresh = () => {
     view.refresh()
···
   const onEndReached = () => {
     view
       .loadMore()
-      .catch(err =>
-        view?.rootStore.log.error('Failed to load more likes', {error: err}),
-      )
+      .catch(err => logger.error('Failed to load more likes', {error: err}))
   }
 
   if (!view.hasLoaded) {

src/view/com/post-thread/PostRepostedBy.tsx

···
 import {ErrorMessage} from '../util/error/ErrorMessage'
 import {useStores} from 'state/index'
 import {usePalette} from 'lib/hooks/usePalette'
+import {logger} from '#/logger'
 
 export const PostRepostedBy = observer(function PostRepostedByImpl({
   uri,
···
   useEffect(() => {
     view
       .loadMore()
-      .catch(err => store.log.error('Failed to fetch reposts', {error: err}))
-  }, [view, store.log])
+      .catch(err => logger.error('Failed to fetch reposts', {error: err}))
+  }, [view])
 
   const onRefresh = () => {
     view.refresh()
···
   const onEndReached = () => {
     view
       .loadMore()
-      .catch(err =>
-        view?.rootStore.log.error('Failed to load more reposts', {error: err}),
-      )
+      .catch(err => logger.error('Failed to load more reposts', {error: err}))
   }
 
   if (!view.hasLoaded) {

src/view/com/post-thread/PostThread.tsx

···
 import {useWebMediaQueries} from 'lib/hooks/useWebMediaQueries'
 import {NavigationProp} from 'lib/routes/types'
 import {sanitizeDisplayName} from 'lib/strings/display-names'
+import {logger} from '#/logger'
 
 const MAINTAIN_VISIBLE_CONTENT_POSITION = {minIndexForVisible: 2}
 
···
     try {
       view?.refresh()
     } catch (err) {
-      view.rootStore.log.error('Failed to refresh posts thread', {error: err})
+      logger.error('Failed to refresh posts thread', {error: err})
     }
     setIsRefreshing(false)
   }, [view, setIsRefreshing])

src/view/com/post-thread/PostThreadItem.tsx

···
 import {makeProfileLink} from 'lib/routes/links'
 import {useWebMediaQueries} from 'lib/hooks/useWebMediaQueries'
 import {MAX_POST_LINES} from 'lib/constants'
+import {logger} from '#/logger'
 
 export const PostThreadItem = observer(function PostThreadItem({
   item,
···
   const onPressToggleRepost = React.useCallback(() => {
     return item
       .toggleRepost()
-      .catch(e => store.log.error('Failed to toggle repost', {error: e}))
-  }, [item, store])
+      .catch(e => logger.error('Failed to toggle repost', {error: e}))
+  }, [item])
 
   const onPressToggleLike = React.useCallback(() => {
     return item
       .toggleLike()
-      .catch(e => store.log.error('Failed to toggle like', {error: e}))
-  }, [item, store])
+      .catch(e => logger.error('Failed to toggle like', {error: e}))
+  }, [item])
 
   const onCopyPostText = React.useCallback(() => {
     Clipboard.setString(record?.text || '')
···
         Toast.show('You will now receive notifications for this thread')
       }
     } catch (e) {
-      store.log.error('Failed to toggle thread mute', {error: e})
+      logger.error('Failed to toggle thread mute', {error: e})
     }
-  }, [item, store])
+  }, [item])
 
   const onDeletePost = React.useCallback(() => {
     item.delete().then(
···
         Toast.show('Post deleted')
       },
       e => {
-        store.log.error('Failed to delete post', {error: e})
+        logger.error('Failed to delete post', {error: e})
         Toast.show('Failed to delete post, please try again')
       },
     )
-  }, [item, store])
+  }, [item])
 
   const onPressShowMore = React.useCallback(() => {
     setLimitLines(false)

src/view/com/post/Post.tsx

···
 import {makeProfileLink} from 'lib/routes/links'
 import {MAX_POST_LINES} from 'lib/constants'
 import {countLines} from 'lib/strings/helpers'
+import {logger} from '#/logger'
 
 export const Post = observer(function PostImpl({
   view,
···
   const onPressToggleRepost = React.useCallback(() => {
     return item
       .toggleRepost()
-      .catch(e => store.log.error('Failed to toggle repost', {error: e}))
-  }, [item, store])
+      .catch(e => logger.error('Failed to toggle repost', {error: e}))
+  }, [item])
 
   const onPressToggleLike = React.useCallback(() => {
     return item
       .toggleLike()
-      .catch(e => store.log.error('Failed to toggle like', {error: e}))
-  }, [item, store])
+      .catch(e => logger.error('Failed to toggle like', {error: e}))
+  }, [item])
 
   const onCopyPostText = React.useCallback(() => {
     Clipboard.setString(record.text)
···
         Toast.show('You will now receive notifications for this thread')
       }
     } catch (e) {
-      store.log.error('Failed to toggle thread mute', {error: e})
+      logger.error('Failed to toggle thread mute', {error: e})
     }
-  }, [item, store])
+  }, [item])
 
   const onDeletePost = React.useCallback(() => {
     item.delete().then(
···
         Toast.show('Post deleted')
       },
       e => {
-        store.log.error('Failed to delete post', {error: e})
+        logger.error('Failed to delete post', {error: e})
         Toast.show('Failed to delete post, please try again')
       },
     )
-  }, [item, setDeleted, store])
+  }, [item, setDeleted])
 
   const onPressShowMore = React.useCallback(() => {
     setLimitLines(false)

src/view/com/posts/Feed.tsx

···
 import {useAnalytics} from 'lib/analytics/analytics'
 import {usePalette} from 'lib/hooks/usePalette'
 import {useTheme} from 'lib/ThemeContext'
+import {logger} from '#/logger'
 
 const LOADING_ITEM = {_reactKey: '__loading__'}
 const EMPTY_FEED_ITEM = {_reactKey: '__empty__'}
···
     try {
       await feed.refresh()
     } catch (err) {
-      feed.rootStore.log.error('Failed to refresh posts feed', {error: err})
+      logger.error('Failed to refresh posts feed', {error: err})
     }
     setIsRefreshing(false)
   }, [feed, track, setIsRefreshing])
···
     try {
       await feed.loadMore()
     } catch (err) {
-      feed.rootStore.log.error('Failed to load more posts', {error: err})
+      logger.error('Failed to load more posts', {error: err})
     }
   }, [feed, track])
 

src/view/com/posts/FeedErrorMessage.tsx

···
 import {useNavigation} from '@react-navigation/native'
 import {NavigationProp} from 'lib/routes/types'
 import {useStores} from 'state/index'
+import {logger} from '#/logger'
 
 const MESSAGES = {
   [KnownError.Unknown]: '',
···
           Toast.show(
             'There was an an issue removing this feed. Please check your internet connection and try again.',
           )
-          store.log.error('Failed to remove feed', {error: err})
+          logger.error('Failed to remove feed', {error: err})
         }
       },
       onPressCancel() {

src/view/com/posts/FeedItem.tsx

···
 import {isEmbedByEmbedder} from 'lib/embeds'
 import {MAX_POST_LINES} from 'lib/constants'
 import {countLines} from 'lib/strings/helpers'
+import {logger} from '#/logger'
 
 export const FeedItem = observer(function FeedItemImpl({
   item,
···
     track('FeedItem:PostRepost')
     return item
       .toggleRepost()
-      .catch(e => store.log.error('Failed to toggle repost', {error: e}))
-  }, [track, item, store])
+      .catch(e => logger.error('Failed to toggle repost', {error: e}))
+  }, [track, item])
 
   const onPressToggleLike = React.useCallback(() => {
     track('FeedItem:PostLike')
     return item
       .toggleLike()
-      .catch(e => store.log.error('Failed to toggle like', {error: e}))
-  }, [track, item, store])
+      .catch(e => logger.error('Failed to toggle like', {error: e}))
+  }, [track, item])
 
   const onCopyPostText = React.useCallback(() => {
     Clipboard.setString(record?.text || '')
···
         Toast.show('You will now receive notifications for this thread')
       }
     } catch (e) {
-      store.log.error('Failed to toggle thread mute', {error: e})
+      logger.error('Failed to toggle thread mute', {error: e})
     }
-  }, [track, item, store])
+  }, [track, item])
 
   const onDeletePost = React.useCallback(() => {
     track('FeedItem:PostDelete')
···
         Toast.show('Post deleted')
       },
       e => {
-        store.log.error('Failed to delete post', {error: e})
+        logger.error('Failed to delete post', {error: e})
         Toast.show('Failed to delete post, please try again')
       },
     )
-  }, [track, item, setDeleted, store])
+  }, [track, item, setDeleted])
 
   const onPressShowMore = React.useCallback(() => {
     setLimitLines(false)

src/view/com/profile/ProfileFollowers.tsx

···
 import {ProfileCardWithFollowBtn} from './ProfileCard'
 import {useStores} from 'state/index'
 import {usePalette} from 'lib/hooks/usePalette'
+import {logger} from '#/logger'
 
 export const ProfileFollowers = observer(function ProfileFollowers({
   name,
···
     view
       .loadMore()
       .catch(err =>
-        store.log.error('Failed to fetch user followers', {error: err}),
+        logger.error('Failed to fetch user followers', {error: err}),
       )
-  }, [view, store.log])
+  }, [view])
 
   const onRefresh = () => {
     view.refresh()
   }
   const onEndReached = () => {
     view.loadMore().catch(err =>
-      view?.rootStore.log.error('Failed to load more followers', {
+      logger.error('Failed to load more followers', {
         error: err,
       }),
     )

src/view/com/profile/ProfileFollows.tsx

···
 import {ProfileCardWithFollowBtn} from './ProfileCard'
 import {useStores} from 'state/index'
 import {usePalette} from 'lib/hooks/usePalette'
+import {logger} from '#/logger'
 
 export const ProfileFollows = observer(function ProfileFollows({
   name,
···
   useEffect(() => {
     view
       .loadMore()
-      .catch(err => store.log.error('Failed to fetch user follows', err))
-  }, [view, store.log])
+      .catch(err => logger.error('Failed to fetch user follows', err))
+  }, [view])
 
   const onRefresh = () => {
     view.refresh()
···
   const onEndReached = () => {
     view
       .loadMore()
-      .catch(err =>
-        view?.rootStore.log.error('Failed to load more follows', err),
-      )
+      .catch(err => logger.error('Failed to load more follows', err))
   }
 
   if (!view.hasLoaded) {

src/view/com/profile/ProfileHeader.tsx

···
 import {makeProfileLink} from 'lib/routes/links'
 import {Link} from '../util/Link'
 import {ProfileHeaderSuggestedFollows} from './ProfileHeaderSuggestedFollows'
+import {logger} from '#/logger'
 
 interface Props {
   view: ProfileModel
···
             : 'ProfileHeader:UnfollowButtonClicked',
         )
       },
-      err => store.log.error('Failed to toggle follow', {error: err}),
+      err => logger.error('Failed to toggle follow', {error: err}),
     )
-  }, [track, view, store.log, setShowSuggestedFollows])
+  }, [track, view, setShowSuggestedFollows])
 
   const onPressEditProfile = React.useCallback(() => {
     track('ProfileHeader:EditProfileButtonClicked')
···
       await view.muteAccount()
       Toast.show('Account muted')
     } catch (e: any) {
-      store.log.error('Failed to mute account', {error: e})
+      logger.error('Failed to mute account', {error: e})
       Toast.show(`There was an issue! ${e.toString()}`)
     }
-  }, [track, view, store])
+  }, [track, view])
 
   const onPressUnmuteAccount = React.useCallback(async () => {
     track('ProfileHeader:UnmuteAccountButtonClicked')
···
       await view.unmuteAccount()
       Toast.show('Account unmuted')
     } catch (e: any) {
-      store.log.error('Failed to unmute account', {error: e})
+      logger.error('Failed to unmute account', {error: e})
       Toast.show(`There was an issue! ${e.toString()}`)
     }
-  }, [track, view, store])
+  }, [track, view])
 
   const onPressBlockAccount = React.useCallback(async () => {
     track('ProfileHeader:BlockAccountButtonClicked')
···
           onRefreshAll()
           Toast.show('Account blocked')
         } catch (e: any) {
-          store.log.error('Failed to block account', {error: e})
+          logger.error('Failed to block account', {error: e})
           Toast.show(`There was an issue! ${e.toString()}`)
         }
       },
···
           onRefreshAll()
           Toast.show('Account unblocked')
         } catch (e: any) {
-          store.log.error('Failed to unblock account', {error: e})
+          logger.error('Failed to unblock account', {error: e})
           Toast.show(`There was an issue! ${e.toString()}`)
         }
       },

src/view/screens/ModerationBlockedAccounts.tsx

···
 import {ViewHeader} from '../com/util/ViewHeader'
 import {CenteredView} from 'view/com/util/Views'
 import {ProfileCard} from 'view/com/profile/ProfileCard'
+import {logger} from '#/logger'
 
 type Props = NativeStackScreenProps<
   CommonNavigatorParams,
···
       blockedAccounts
         .loadMore()
         .catch(err =>
-          store.log.error('Failed to load more blocked accounts', {error: err}),
+          logger.error('Failed to load more blocked accounts', {error: err}),
         )
-    }, [blockedAccounts, store])
+    }, [blockedAccounts])
 
     const renderItem = ({
       item,

src/view/screens/ModerationMutedAccounts.tsx

···
 import {ViewHeader} from '../com/util/ViewHeader'
 import {CenteredView} from 'view/com/util/Views'
 import {ProfileCard} from 'view/com/profile/ProfileCard'
+import {logger} from '#/logger'
 
 type Props = NativeStackScreenProps<
   CommonNavigatorParams,
···
       mutedAccounts
         .loadMore()
         .catch(err =>
-          store.log.error('Failed to load more muted accounts', {error: err}),
+          logger.error('Failed to load more muted accounts', {error: err}),
         )
-    }, [mutedAccounts, store])
+    }, [mutedAccounts])
 
     const renderItem = ({
       item,

src/view/screens/Notifications.tsx

···
 import {s, colors} from 'lib/styles'
 import {useAnalytics} from 'lib/analytics/analytics'
 import {isWeb} from 'platform/detection'
+import {logger} from '#/logger'
 
 type Props = NativeStackScreenProps<
   NotificationsTabNavigatorParams,
···
     useFocusEffect(
       React.useCallback(() => {
         store.shell.setMinimalShellMode(false)
-        store.log.debug('NotificationsScreen: Updating feed')
+        logger.debug('NotificationsScreen: Updating feed')
         const softResetSub = store.onScreenSoftReset(onPressLoadLatest)
         store.me.notifications.update()
         screen('Notifications')

src/view/screens/PostThread.tsx

···
 import {useSafeAreaInsets} from 'react-native-safe-area-context'
 import {clamp} from 'lodash'
 import {useWebMediaQueries} from 'lib/hooks/useWebMediaQueries'
+import {logger} from '#/logger'
 
 const SHELL_FOOTER_HEIGHT = 44
 
···
         InteractionManager.runAfterInteractions(() => {
           if (!view.hasLoaded && !view.isLoading) {
             view.setup().catch(err => {
-              store.log.error('Failed to fetch thread', {error: err})
+              logger.error('Failed to fetch thread', {error: err})
             })
           }
         })

src/view/screens/Profile.tsx

···
 import {FeedSourceModel} from 'state/models/content/feed-source'
 import {useSetTitle} from 'lib/hooks/useSetTitle'
 import {combinedDisplayName} from 'lib/strings/display-names'
+import {logger} from '#/logger'
 
 type Props = NativeStackScreenProps<CommonNavigatorParams, 'Profile'>
 export const ProfileScreen = withAuthRequired(
···
       uiState
         .refresh()
         .catch((err: any) =>
-          store.log.error('Failed to refresh user profile', {error: err}),
+          logger.error('Failed to refresh user profile', {error: err}),
         )
-    }, [uiState, store])
+    }, [uiState])
     const onEndReached = React.useCallback(() => {
       uiState.loadMore().catch((err: any) =>
-        store.log.error('Failed to load more entries in user profile', {
+        logger.error('Failed to load more entries in user profile', {
           error: err,
         }),
       )
-    }, [uiState, store])
+    }, [uiState])
     const onPressTryAgain = React.useCallback(() => {
       uiState.setup()
     }, [uiState])

src/view/screens/ProfileFeed.tsx

···
 import {sanitizeHandle} from 'lib/strings/handles'
 import {makeProfileLink} from 'lib/routes/links'
 import {ComposeIcon2} from 'lib/icons'
+import {logger} from '#/logger'
 
 const SECTION_TITLES = ['Posts', 'About']
 
···
         Toast.show(
           'There was an an issue updating your feeds, please check your internet connection and try again.',
         )
-        store.log.error('Failed up update feeds', {error: err})
+        logger.error('Failed up update feeds', {error: err})
       }
-    }, [store, feedInfo])
+    }, [feedInfo])
 
     const onToggleLiked = React.useCallback(async () => {
       Haptics.default()
···
         Toast.show(
           'There was an an issue contacting the server, please check your internet connection and try again.',
         )
-        store.log.error('Failed up toggle like', {error: err})
+        logger.error('Failed up toggle like', {error: err})
       }
-    }, [store, feedInfo])
+    }, [feedInfo])
 
     const onTogglePinned = React.useCallback(async () => {
       Haptics.default()
       if (feedInfo) {
         feedInfo.togglePin().catch(e => {
           Toast.show('There was an issue contacting the server')
-          store.log.error('Failed to toggle pinned feed', {error: e})
+          logger.error('Failed to toggle pinned feed', {error: e})
         })
       }
-    }, [store, feedInfo])
+    }, [feedInfo])
 
     const onPressShare = React.useCallback(() => {
       const url = toShareUrl(`/profile/${handleOrDid}/feed/${rkey}`)

src/view/screens/ProfileList.tsx

···
 import {makeProfileLink, makeListLink} from 'lib/routes/links'
 import {ComposeIcon2} from 'lib/icons'
 import {ListItems} from 'view/com/lists/ListItems'
+import {logger} from '#/logger'
 
 const SECTION_TITLES_CURATE = ['Posts', 'About']
 const SECTION_TITLES_MOD = ['About']
···
     Haptics.default()
     list.togglePin().catch(e => {
       Toast.show('There was an issue contacting the server')
-      store.log.error('Failed to toggle pinned list', {error: e})
+      logger.error('Failed to toggle pinned list', {error: e})
     })
-  }, [store, list])
+  }, [list])
 
   const onSubscribeMute = useCallback(() => {
     store.shell.openModal({

src/view/screens/SavedFeeds.tsx

···
 import * as Toast from 'view/com/util/Toast'
 import {Haptics} from 'lib/haptics'
 import {TextLink} from 'view/com/util/Link'
+import {logger} from '#/logger'
 
 const HITSLOP_TOP = {
   top: 20,
···
   item: FeedSourceModel
 }) {
   const pal = usePalette('default')
-  const store = useStores()
   const isPinned = item.isPinned
 
   const onTogglePinned = useCallback(() => {
     Haptics.default()
     item.togglePin().catch(e => {
       Toast.show('There was an issue contacting the server')
-      store.log.error('Failed to toggle pinned feed', {error: e})
+      logger.error('Failed to toggle pinned feed', {error: e})
     })
-  }, [item, store])
+  }, [item])
   const onPressUp = useCallback(
     () =>
       savedFeeds.movePinnedFeed(item, 'up').catch(e => {
         Toast.show('There was an issue contacting the server')
-        store.log.error('Failed to set pinned feed order', {error: e})
+        logger.error('Failed to set pinned feed order', {error: e})
       }),
-    [store, savedFeeds, item],
+    [savedFeeds, item],
   )
   const onPressDown = useCallback(
     () =>
       savedFeeds.movePinnedFeed(item, 'down').catch(e => {
         Toast.show('There was an issue contacting the server')
-        store.log.error('Failed to set pinned feed order', {error: e})
+        logger.error('Failed to set pinned feed order', {error: e})
       }),
-    [store, savedFeeds, item],
+    [savedFeeds, item],
   )
 
   return (

src/view/screens/Settings.tsx

···
 import Clipboard from '@react-native-clipboard/clipboard'
 import {makeProfileLink} from 'lib/routes/links'
 import {AccountDropdownBtn} from 'view/com/util/AccountDropdownBtn'
+import {logger} from '#/logger'
 
 // TEMPORARY (APP-700)
 // remove after backend testing finishes
···
               Toast.show('Your handle has been updated')
             },
             err => {
-              store.log.error(
-                'Failed to reload from server after handle update',
-                {error: err},
-              )
+              logger.error('Failed to reload from server after handle update', {
+                error: err,
+              })
               setIsSwitching(false)
             },
           )