refactor: standardize logging messages across multiple services for clarity and consistency

Author: jakejarvis

lib/schedule.ts

@@ -63,7 +63,7 @@ export async function scheduleRevalidation(
 
   // Check if domain should stop being revalidated due to inactivity
   if (shouldStopRevalidation(section, lastAccessedAt ?? null)) {
-    logger.info(`skip ${section} ${normalizedDomain} (stopped: inactive)`, {
+    logger.info("skip (stopped: inactive)", {
       domain: normalizedDomain,
       section,
       lastAccessedAt: lastAccessedAt?.toISOString() ?? "never",
@@ -85,7 +85,7 @@ export async function scheduleRevalidation(
     const daysInactive = lastAccessedAt
       ? Math.floor((now - lastAccessedAt.getTime()) / (1000 * 60 * 60 * 24))
       : null;
-    logger.info(`decay ${section} ${normalizedDomain}`, {
+    logger.info("decay set", {
       domain: normalizedDomain,
       section,
       decayMultiplier,
@@ -120,14 +120,14 @@ export async function scheduleRevalidation(
       id: eventId,
     });
 
-    logger.debug(`ok ${section} ${normalizedDomain}`, {
+    logger.debug("done", {
       domain: normalizedDomain,
       section,
       scheduledAt: new Date(scheduledDueMs).toISOString(),
     });
     return true;
   } catch (err) {
-    logger.error(`failed ${section} ${normalizedDomain}`, err, {
+    logger.error("unexpected failure", err, {
       domain: normalizedDomain,
       section,
     });

lib/storage.ts

@@ -69,7 +69,7 @@ async function uploadWithRetry(
         cacheControlMaxAge,
       });
 
-      logger.info(`upload ok ${pathname}`, {
+      logger.info("upload ok", {
         pathname,
         attempts: attempt + 1,
       });

server/services/certificates.ts

@@ -19,7 +19,7 @@ import { ttlForCertificates } from "@/lib/ttl";
 const logger = createLogger({ source: "certificates" });
 
 export async function getCertificates(domain: string): Promise<Certificate[]> {
-  logger.debug(`start ${domain}`, { domain });
+  logger.debug("start", { domain });
 
   // Only support registrable domains (no subdomains, IPs, or invalid TLDs)
   const registrable = toRegistrableDomain(domain);
@@ -67,7 +67,7 @@ export async function getCertificates(domain: string): Promise<Certificate[]> {
         caProvider: detectCertificateAuthority(c.issuer),
       }));
 
-      logger.info(`cache hit ${registrable}`, {
+      logger.info("cache hit", {
         domain: registrable,
         count: out.length,
         cached: true,
@@ -189,13 +189,13 @@ export async function getCertificates(domain: string): Promise<Certificate[]> {
       });
     }
 
-    logger.info(`ok ${registrable}`, {
+    logger.info("done", {
       domain: registrable,
       chainLength: out.length,
     });
     return out;
   } catch (err) {
-    logger.error(`error ${registrable}`, err, { domain: registrable });
+    logger.error("probe failed", err, { domain: registrable });
     // Do not treat as fatal; return empty and avoid long-lived negative cache
     return [];
   }

server/services/dns.ts

@@ -84,7 +84,7 @@ function buildDohUrl(
 export const resolveAll = cache(async function resolveAll(
   domain: string,
 ): Promise<DnsResolveResult> {
-  logger.debug(`start ${domain}`, { domain });
+  logger.debug("start", { domain });
 
   const providers = providerOrderForLookup(domain);
   const durationByProvider: Record<string, number> = {};
@@ -170,7 +170,7 @@ export const resolveAll = cache(async function resolveAll(
     const deduplicated = deduplicateDnsRecords(assembled);
     const sorted = sortDnsRecordsByType(deduplicated, types);
     if (allFreshAcrossTypes) {
-      logger.info(`cache hit ${registrable}`, {
+      logger.info("cache hit", {
         domain: registrable,
         types: freshTypes.join(","),
         cached: true,
@@ -284,7 +284,7 @@ export const resolveAll = cache(async function resolveAll(
           { A: 0, AAAA: 0, MX: 0, TXT: 0, NS: 0 } as Record<DnsType, number>,
         );
 
-        logger.info(`ok partial ${registrable}`, {
+        logger.info("partial refresh done", {
           domain: registrable,
           counts,
           resolver: pinnedProvider.key,
@@ -391,7 +391,7 @@ export const resolveAll = cache(async function resolveAll(
           });
         });
       }
-      logger.info(`ok ${registrable}`, {
+      logger.info("done", {
         domain: registrable,
         counts,
         resolver: resolverUsed,
@@ -403,7 +403,7 @@ export const resolveAll = cache(async function resolveAll(
       const sorted = sortDnsRecordsByType(deduplicated, types);
       return { records: sorted, resolver: resolverUsed } as DnsResolveResult;
     } catch (err) {
-      logger.warn(`provider attempt failed ${registrable}`, {
+      logger.warn("provider attempt failed", {
         domain: registrable,
         provider: provider.key,
       });
@@ -417,7 +417,7 @@ export const resolveAll = cache(async function resolveAll(
   const error = new Error(
     `All DoH providers failed for ${registrable}: ${String(lastError)}`,
   );
-  logger.error(`all providers failed ${registrable}`, error, {
+  logger.error("all providers failed", error, {
     domain: registrable,
     providers: providers.map((p) => p.key).join(","),
   });

server/services/favicon.ts

@@ -60,7 +60,7 @@ async function fetchFaviconInternal(
   // Safety: Auto-cleanup stale promise after timeout
   const timeoutId = setTimeout(() => {
     if (faviconPromises.get(registrable) === promise) {
-      logger.warn(`cleaning up stale promise for ${registrable}`, {
+      logger.warn("cleaning up stale promise", {
         domain: registrable,
         timeoutMs: PROMISE_CLEANUP_TIMEOUT_MS,
       });

server/services/headers.ts

@@ -27,7 +27,7 @@ export const probeHeaders = cache(async function probeHeaders(
   domain: string,
 ): Promise<HttpHeadersResponse> {
   const url = `https://${domain}/`;
-  logger.debug(`start ${domain}`, { domain });
+  logger.debug("start", { domain });
 
   // Only support registrable domains (no subdomains, IPs, or invalid TLDs)
   const registrable = toRegistrableDomain(domain);
@@ -65,7 +65,7 @@ export const probeHeaders = cache(async function probeHeaders(
       statusMessage = undefined;
     }
 
-    logger.info(`cache hit ${registrable}`, {
+    logger.info("cache hit", {
       domain: registrable,
       status: row.status,
       count: normalized.length,
@@ -116,7 +116,7 @@ export const probeHeaders = cache(async function probeHeaders(
         });
       });
     }
-    logger.info(`ok ${registrable}`, {
+    logger.info("done", {
       domain: registrable,
       status: final.status,
       count: normalized.length,
@@ -137,11 +137,11 @@ export const probeHeaders = cache(async function probeHeaders(
     const isDnsError = isExpectedDnsError(err);
 
     if (isDnsError) {
-      logger.debug(`no web hosting ${registrable} (no A/AAAA records)`, {
+      logger.debug("no web hosting (no A/AAAA records)", {
         domain: registrable,
       });
     } else {
-      logger.error(`error ${registrable}`, err, { domain: registrable });
+      logger.error("probe failed", err, { domain: registrable });
     }
 
     // Return empty on failure without caching to avoid long-lived negatives

server/services/hosting.ts

@@ -39,7 +39,7 @@ const logger = createLogger({ source: "hosting" });
 export const detectHosting = cache(async function detectHosting(
   domain: string,
 ): Promise<Hosting> {
-  logger.debug(`start ${domain}`, { domain });
+  logger.debug("start", { domain });
 
   // Only support registrable domains (no subdomains, IPs, or invalid TLDs)
   const registrable = toRegistrableDomain(domain);
@@ -103,7 +103,7 @@ export const detectHosting = cache(async function detectHosting(
           lon: row.geoLon ?? null,
         },
       };
-      logger.info(`cache hit ${domain}`, {
+      logger.info("cache hit", {
         domain,
         hosting: info.hostingProvider.name,
         email: info.emailProvider.name,
@@ -126,7 +126,7 @@ export const detectHosting = cache(async function detectHosting(
   const [headersResponse, meta] = await Promise.all([
     hasWebHosting
       ? probeHeaders(domain).catch((err) => {
-          logger.error(`headers probe error ${domain}`, err, { domain });
+          logger.error("headers probe error", err, { domain });
           return {
             headers: [] as { name: string; value: string }[],
             status: 0,
@@ -284,11 +284,13 @@ export const detectHosting = cache(async function detectHosting(
       });
     });
   }
-  logger.info(`ok ${registrable}`, {
+
+  logger.info("done", {
     domain: registrable,
     hosting: hostingName,
     email: emailName,
     dns: dnsName,
   });
+
   return info;
 });

server/services/ip.ts

@@ -24,7 +24,8 @@ export const lookupIpMeta = cache(async function lookupIpMeta(
   owner: string | null;
   domain: string | null;
 }> {
-  logger.debug(`start lookup for ${ip}`, { type: "ip" });
+  logger.debug("start", { ip });
+
   try {
     // Add timeout to prevent hanging requests to upstream IP service
     const controller = new AbortController();
@@ -37,8 +38,8 @@ export const lookupIpMeta = cache(async function lookupIpMeta(
       clearTimeout(timeoutId);
 
       if (!res.ok) {
-        logger.error(`error looking up ${ip}`, undefined, {
-          type: "ip",
+        logger.error("lookup failed", undefined, {
+          ip,
           status: res.status,
           statusMessage: res.statusText,
         });
@@ -98,8 +99,8 @@ export const lookupIpMeta = cache(async function lookupIpMeta(
         lon: typeof data.longitude === "number" ? data.longitude : null,
       };
 
-      logger.info(`ok ${ip}`, {
-        type: "ip",
+      logger.info("done", {
+        ip,
         owner: owner || "none",
         domain: domain || "none",
       });
@@ -111,7 +112,7 @@ export const lookupIpMeta = cache(async function lookupIpMeta(
       throw fetchErr;
     }
   } catch (err) {
-    logger.error(`error looking up ${ip}`, err, { type: "ip" });
+    logger.error("lookup failed", err, { ip });
     return {
       owner: null,
       domain: null,

server/services/pricing.ts

@@ -51,12 +51,10 @@ async function fetchProviderPricing(
 ): Promise<RegistrarPricingResponse | null> {
   try {
     const payload = await provider.fetchPricing();
-    logger.info(`fetch ok ${provider.name}`, { provider: provider.name });
+    logger.info("fetch ok", { provider: provider.name });
     return payload;
   } catch (err) {
-    logger.error(`fetch error ${provider.name}`, err, {
-      provider: provider.name,
-    });
+    logger.error("fetch error", err, { provider: provider.name });
     return null;
   }
 }
@@ -90,7 +88,7 @@ const porkbunProvider: PricingProvider = {
       );
 
       if (!res.ok) {
-        logger.error(`upstream error porkbun status=${res.status}`, undefined, {
+        logger.error("upstream error", undefined, {
           provider: "porkbun",
           status: res.status,
         });
@@ -139,14 +137,10 @@ const cloudflareProvider: PricingProvider = {
       });
 
       if (!res.ok) {
-        logger.error(
-          `upstream error cloudflare status=${res.status}`,
-          undefined,
-          {
-            provider: "cloudflare",
-            status: res.status,
-          },
-        );
+        logger.error("upstream error", undefined, {
+          provider: "cloudflare",
+          status: res.status,
+        });
         throw new Error(`Cloudflare pricing API returned ${res.status}`);
       }
 

server/services/registration.ts

@@ -55,7 +55,7 @@ function normalizeRegistrar(registrar?: { name?: unknown; url?: unknown }): {
  * Fetch domain registration using rdapper and cache the normalized DomainRecord.
  */
 export async function getRegistration(domain: string): Promise<Registration> {
-  logger.debug(`start ${domain}`, { domain });
+  logger.debug("start", { domain });
 
   // Only support registrable domains (no subdomains, IPs, or invalid TLDs)
   const registrable = toRegistrableDomain(domain);
@@ -132,12 +132,7 @@ export async function getRegistration(domain: string): Promise<Registration> {
       });
     });
 
-    logger.info(`ok cached ${registrable}`, {
-      domain: registrable,
-      isRegistered: row.registration.isRegistered,
-      registrar: registrarProvider.name,
-      cached: true,
-    });
+    logger.info("cache hit", { domain: registrable });
 
     return response;
   }
@@ -185,10 +180,7 @@ export async function getRegistration(domain: string): Promise<Registration> {
 
   // If unregistered, return response without persisting to Postgres
   if (!record.isRegistered) {
-    logger.info(`ok ${registrable} unregistered (not persisted)`, {
-      domain: registrable,
-      isRegistered: false,
-    });
+    logger.info("unregistered (not persisted)", { domain: registrable });
 
     const registrarProvider = normalizeRegistrar(record.registrar ?? {});
 
@@ -311,11 +303,7 @@ export async function getRegistration(domain: string): Promise<Registration> {
     });
   });
 
-  logger.info(`ok ${registrable}`, {
-    domain: registrable,
-    isRegistered: record.isRegistered,
-    registrar: withProvider.registrarProvider.name,
-  });
+  logger.info("done", { domain: registrable });
 
   return withProvider;
 }