Feature/174 log streaming external sink

package.json

@@ -53,6 +53,7 @@
     "@prisma/client": "^7.8.0",
     "@prisma/driver-adapter-utils": "^7.8.0",
     "@stellar/stellar-sdk": "^14.6.1",
+    "@tanstack/react-query": "^5.100.5",
     "@types/node": "^22.0.0",
     "@types/pdfkit": "^0.17.6",
     "@types/pg": "^8.20.0",

src/components/providers/QueryProvider.tsx

@@ -0,0 +1,10 @@
+import { QueryClientProvider } from '@tanstack/react-query'
+import { queryClient } from '../../lib/queryClient'
+
+export const QueryProvider = ({ children }: { children: React.ReactNode }) => {
+  return (
+    <QueryClientProvider client={queryClient}>
+      {children}
+    </QueryClientProvider>
+  )
+}

src/config/logger.ts

@@ -0,0 +1,34 @@
+import winston from 'winston';
+
+import { HttpLogTransport }
+  from '../transports/httpLogTransport';
+
+const transports = [
+  new winston.transports.Console(),
+];
+
+if (
+  process.env
+    .LOG_STREAM_ENABLED ===
+  'true'
+) {
+  transports.push(
+    new HttpLogTransport({
+      level: 'info',
+    }),
+  );
+}
+
+export const logger =
+  winston.createLogger({
+    level: 'info',
+
+    format:
+      winston.format.combine(
+        winston.format.timestamp(),
+
+        winston.format.json(),
+      ),
+
+    transports,
+  });

src/hooks/usePrices.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query'
+import { api } from '../services/api'
+
+export const usePrices = () => {
+  return useQuery({
+    queryKey: ['prices'],
+    queryFn: api.getPrices,
+
+    // 🔥 SWR behavior tuning
+    staleTime: 10 * 1000,   // prices go stale fast
+    refetchInterval: 15 * 1000, // auto refresh every 15s
+
+    placeholderData: (previousData) => previousData, // 👈 instant UI
+  })
+}

src/lib/queryClient.ts

@@ -0,0 +1,13 @@
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 30 * 1000,          // 30s → data considered fresh
+      gcTime: 5 * 60 * 1000,         // cache persists 5 mins
+      refetchOnWindowFocus: false,   // 🔥 your requirement
+      refetchOnReconnect: true,
+      retry: 2,
+    },
+  },
+})

src/services/api.ts

@@ -0,0 +1,13 @@
+export const api = {
+  async getPrices() {
+    const res = await fetch('/api/prices')
+    if (!res.ok) throw new Error('Failed to fetch prices')
+    return res.json()
+  },
+
+  async getPortfolio() {
+    const res = await fetch('/api/portfolio')
+    if (!res.ok) throw new Error('Failed to fetch portfolio')
+    return res.json()
+  },
+}

src/transport/httpLogTransport.ts

@@ -0,0 +1,83 @@
+import Transport from 'winston-transport';
+import axios from 'axios';
+
+interface HttpTransportOptions {
+  level?: string;
+}
+
+export class HttpLogTransport extends Transport {
+  private queue: any[] = [];
+
+  private flushing = false;
+
+  constructor(
+    opts: HttpTransportOptions,
+  ) {
+    super(opts);
+
+    setInterval(
+      () => this.flush(),
+      3000,
+    );
+  }
+
+  log(info: any, callback: () => void) {
+    setImmediate(() => {
+      this.emit('logged', info);
+    });
+
+    this.queue.push({
+      timestamp:
+        new Date().toISOString(),
+      level: info.level,
+      message: info.message,
+      meta: info.meta ?? {},
+    });
+
+    callback();
+  }
+
+  private async flush() {
+    if (
+      this.flushing ||
+      this.queue.length === 0
+    ) {
+      return;
+    }
+
+    this.flushing = true;
+
+    const batch =
+      this.queue.splice(0, 20);
+
+    try {
+      await axios.post(
+        process.env.LOG_STREAM_URL!,
+        batch,
+        {
+          timeout: Number(
+            process.env
+              .LOG_STREAM_TIMEOUT_MS ??
+              2000,
+          ),
+
+          headers: {
+            Authorization:
+              `Bearer ${process.env.LOG_STREAM_TOKEN}`,
+            'Content-Type':
+              'application/json',
+          },
+        },
+      );
+    } catch (error) {
+      console.error(
+        '[log-stream] failed to stream logs',
+      );
+
+      // Requeue logs to avoid loss
+      this.queue.unshift(...batch);
+    } finally {
+      this.flushing = false;
+    }
+  }
+}