@od-oneapp/observability 2026.1.1301

package/src/server.ts

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Auto-configuring server export for Node.js environments (non-Next.js)
+ * Auto-configuring server export for Node.js environments (non-Next.js)
+ */
+
+import { safeEnv } from '../env';
+
+import { ObservabilityBuilder } from './factory/builder';
+import { createConsoleServerPlugin } from './plugins/console';
+import { shouldEnableConsole } from './shared';
+
+/**
+ * Auto-configured observability for Node.js server environments
+ * Automatically sets up console logging based on environment variables
+ */
+const builder = ObservabilityBuilder.create();
+
+// Console logging control using shared utility
+const env = safeEnv();
+const enableConsole = shouldEnableConsole(
+  env.NEXT_PUBLIC_NODE_ENV,
+  env.NEXT_PUBLIC_OBSERVABILITY_CONSOLE_ENABLED,
+  env.NEXT_PUBLIC_OBSERVABILITY_DEBUG,
+);
+
+// Always add console plugin, control via enabled flag
+builder.withPlugin(
+  createConsoleServerPlugin({
+    prefix: '[Server]',
+    enabled: enableConsole,
+  }),
+);
+
+// Note: Production providers would typically be configured by the app
+// This is just a fallback for non-Next.js server usage
+
+/**
+ * Pre-configured observability instance for Node.js server environments
+ * Includes console logging with automatic environment-based configuration
+ */
+export const observability = builder.build();
+
+// Export types and utilities
+export * from './core/types';
+export { createObservability } from './factory';
+export { ObservabilityBuilder } from './factory/builder';
+
+/**
+ * Synchronous logger functions for non-Next.js Node.js environments.
+ * These are bound to a pre-built observability instance at module load time.
+ *
+ * Note: For Next.js apps, use `@repo/observability/server/next` instead,
+ * which provides async loggers that support lazy initialization.
+ *
+ * @example
+ * ```typescript
+ * import { logInfo, logError } from '@repo/shared/logger';
+ * logInfo('Server started', { port: 3000 });
+ * logError('Database connection failed', { error: err });
+ * ```
+ */
+// Legacy function for backward compatibility (no-op)
+/**
+ * @deprecated Configuration now happens through the observability system
+ */
+export const configureLogger = () => {
+  // No-op: Configuration now happens through the observability system
+};
+
+// Re-export type
+export type LogContext = Record<string, any>;

package/src/shared.ts

@@ -0,0 +1,148 @@
+/**
+ * @fileoverview Shared observability utilities and types
+ * Shared observability utilities and types
+ */
+
+import { logWarn } from '@repo/shared/logger';
+
+/**
+ * Get runtime environment information.
+ *
+ * Detects the current runtime environment (browser, Node.js, edge, Bun) and returns
+ * detailed information about the environment type, version, and capabilities.
+ *
+ * @returns Runtime information object with type, version, and environment-specific details
+ *
+ * @example
+ * ```typescript
+ * const runtime = getRuntimeInfo();
+ * // Returns: { type: 'node', version: '22.0.0', major: 22, minor: 0, isNode22Plus: true, isNextJs: true }
+ * // or: { type: 'browser', isNextJs: true }
+ * // or: { type: 'edge', variant: 'vercel' }
+ * ```
+ */
+export const getRuntimeInfo = () => {
+  // Edge runtime detection (Vercel Edge, Cloudflare Workers)
+  if (typeof globalThis !== 'undefined' && (globalThis as any).EdgeRuntime) {
+    return { type: 'edge', variant: 'vercel' };
+  }
+  if (
+    typeof globalThis !== 'undefined' &&
+    (globalThis as any).caches &&
+    typeof (globalThis as any).caches !== 'undefined'
+  ) {
+    return { type: 'edge', variant: 'cloudflare' };
+  }
+
+  // Bun detection
+  if (typeof process !== 'undefined' && process.versions?.bun) {
+    return { type: 'bun', version: process.versions.bun };
+  }
+
+  // Browser detection (more robust)
+  if (
+    typeof globalThis !== 'undefined' &&
+    'window' in globalThis &&
+    typeof (globalThis as any).window !== 'undefined' &&
+    typeof (globalThis as any).window.document !== 'undefined' &&
+    typeof (globalThis as any).window.navigator !== 'undefined'
+  ) {
+    return { type: 'browser', isNextJs: Boolean((globalThis as any).window.__NEXT_DATA__) };
+  }
+
+  // Node.js detection with version check
+  if (typeof process !== 'undefined' && process.versions?.node) {
+    const nodeVersion = parseInt(process.versions.node.split('.')[0] ?? '0');
+    const nodeVersionMinor = parseInt(process.versions.node.split('.')[1] ?? '0');
+
+    if (nodeVersion < 22) {
+      // Note: Using logWarn here - observability system may not be initialized yet, but shared logger is always available
+      logWarn(
+        `[Observability] Node ${process.versions.node} detected. Node 22+ is required for optimal performance and latest features.`,
+      );
+    }
+
+    return {
+      type: 'node',
+      version: process.versions.node,
+      major: nodeVersion,
+      minor: nodeVersionMinor,
+      isNode22Plus: nodeVersion >= 22,
+      isNextJs:
+        Boolean(process.env.NEXT_RUNTIME) ||
+        Boolean(process.env.__NEXT_RUNTIME) ||
+        Boolean(process.env.NEXT_PUBLIC_VERCEL_ENV),
+    };
+  }
+
+  // Fallback
+  return { type: 'unknown' };
+};
+
+// Cache the runtime info
+const runtimeInfo = getRuntimeInfo();
+
+/**
+ * Get cached runtime environment information.
+ *
+ * Returns the runtime information that was detected at module load time.
+ * This is cached to avoid repeated detection checks.
+ *
+ * @returns Cached runtime information object
+ *
+ * @example
+ * ```typescript
+ * const runtime = getRuntimeEnvironment();
+ * console.log(runtime.type); // 'node', 'browser', 'edge', etc.
+ * ```
+ */
+export const getRuntimeEnvironment = () => runtimeInfo;
+
+/**
+ * Detect if code is running in a browser environment
+ * Extracted to shared utility to avoid duplication
+ * @returns true if running in browser, false otherwise
+ */
+export function isBrowser(): boolean {
+  return (
+    typeof globalThis !== 'undefined' &&
+    'window' in globalThis &&
+    typeof (globalThis as any).window !== 'undefined' &&
+    typeof (globalThis as any).window.document !== 'undefined' &&
+    typeof (globalThis as any).window.navigator !== 'undefined'
+  );
+}
+
+/**
+ * Determine if console logging should be enabled based on environment
+ * Centralized logic to avoid duplication across entry points
+ * @param envNodeEnv - The NEXT_PUBLIC_NODE_ENV value
+ * @param consoleEnabled - The NEXT_PUBLIC_OBSERVABILITY_CONSOLE_ENABLED value (explicit control)
+ * @param debugEnabled - The NEXT_PUBLIC_OBSERVABILITY_DEBUG value
+ * @returns boolean indicating if console should be enabled
+ */
+export function shouldEnableConsole(
+  envNodeEnv?: string,
+  consoleEnabled?: boolean,
+  debugEnabled?: boolean,
+): boolean {
+  const isDevelopment = envNodeEnv === 'development' || process.env.NODE_ENV === 'development';
+
+  // Priority: explicit control > development mode > debug mode
+  if (consoleEnabled !== undefined) {
+    return consoleEnabled;
+  }
+  if (isDevelopment) {
+    return true;
+  }
+  return debugEnabled ?? false;
+}
+
+// Export types for convenience - removed for Rollup compatibility
+
+// Note: For direct access to observability instances, import from environment-specific modules:
+// - @repo/observability/client-next
+// - @repo/observability/server-next
+// - @repo/observability/server-edge
+// - @repo/observability/client
+// - @repo/observability/server