@sochdb/sochdb 0.4.0

package/dist/esm/analytics.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * SochDB Analytics - Anonymous usage tracking with PostHog
+ *
+ * This module provides anonymous, privacy-respecting analytics to help
+ * improve SochDB. All tracking can be disabled by setting:
+ *
+ *     SOCHDB_DISABLE_ANALYTICS=true
+ *
+ * No personally identifiable information (PII) is collected. Only aggregate
+ * usage patterns are tracked to understand:
+ * - Which features are most used
+ * - Performance characteristics
+ * - Error patterns for debugging
+ *
+ * Copyright 2025 Sushanth (https://github.com/sushanthpy)
+ * Licensed under the Apache License, Version 2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnalyticsDisabled = isAnalyticsDisabled;
+exports.capture = capture;
+exports.captureError = captureError;
+exports.shutdown = shutdown;
+exports.trackDatabaseOpen = trackDatabaseOpen;
+const crypto_1 = require("crypto");
+const os_1 = require("os");
+// PostHog configuration
+const POSTHOG_API_KEY = "phc_zf0hm6ZmPUJj1pM07Kigqvphh1ClhKX1NahRU4G0bfu";
+const POSTHOG_HOST = "https://us.i.posthog.com";
+// Lazy-loaded PostHog client
+let posthogClient = null;
+let posthogInitialized = false;
+/**
+ * Check if analytics is disabled via environment variable.
+ *
+ * Analytics is disabled when SOCHDB_DISABLE_ANALYTICS is set to 'true', '1', 'yes', or 'on'.
+ *
+ * @returns true if analytics is disabled
+ */
+function isAnalyticsDisabled() {
+    const disableVar = (process.env.SOCHDB_DISABLE_ANALYTICS || "").toLowerCase();
+    return ["true", "1", "yes", "on"].includes(disableVar);
+}
+/**
+ * Generate a stable anonymous ID for this machine.
+ *
+ * Uses a hash of machine-specific but non-identifying information.
+ * The same machine will always get the same ID, but the ID cannot
+ * be reversed to identify the machine.
+ */
+function getAnonymousId() {
+    try {
+        const machineInfo = [
+            (0, os_1.hostname)(),
+            (0, os_1.platform)(),
+            (0, os_1.arch)(),
+            process.getuid?.() ?? "windows",
+        ].join("|");
+        return (0, crypto_1.createHash)("sha256").update(machineInfo).digest("hex").slice(0, 16);
+    }
+    catch {
+        return "anonymous";
+    }
+}
+/**
+ * Lazily initialize PostHog client.
+ */
+async function getPosthogClient() {
+    if (isAnalyticsDisabled()) {
+        return null;
+    }
+    if (posthogInitialized) {
+        return posthogClient;
+    }
+    posthogInitialized = true;
+    try {
+        // Use require to avoid TypeScript checking the optional module
+        // This allows the SDK to work without posthog-node installed
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const posthogModule = require("posthog-node");
+        const { PostHog } = posthogModule;
+        posthogClient = new PostHog(POSTHOG_API_KEY, {
+            host: POSTHOG_HOST,
+        });
+        return posthogClient;
+    }
+    catch {
+        // posthog-node not installed or error - analytics disabled
+        return null;
+    }
+}
+/**
+ * Get the SDK version.
+ */
+function getSdkVersion() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg = require("../package.json");
+        return pkg.version || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * Capture an analytics event.
+ *
+ * This function is a no-op if:
+ * - SOCHDB_DISABLE_ANALYTICS=true
+ * - posthog-node package is not installed
+ * - Any error occurs (fails silently)
+ *
+ * @param event - Event name (e.g., "database_opened", "vector_search")
+ * @param properties - Optional event properties
+ * @param distinctId - Optional distinct ID (defaults to anonymous machine ID)
+ */
+async function capture(event, properties, distinctId) {
+    if (isAnalyticsDisabled()) {
+        return;
+    }
+    try {
+        const client = await getPosthogClient();
+        if (!client) {
+            return;
+        }
+        // Build properties with SDK context
+        const eventProperties = {
+            sdk: "nodejs",
+            sdk_version: getSdkVersion(),
+            node_version: process.version,
+            os: (0, os_1.platform)(),
+            arch: (0, os_1.arch)(),
+            ...properties,
+        };
+        client.capture({
+            distinctId: distinctId || getAnonymousId(),
+            event,
+            properties: eventProperties,
+        });
+        // Flush to ensure event is sent immediately
+        await client.flush();
+    }
+    catch {
+        // Never let analytics break user code
+    }
+}
+/**
+ * Capture an error event for debugging.
+ *
+ * Only sends static information - no dynamic error messages.
+ *
+ * @param errorType - Static error category (e.g., "connection_error", "query_error", "timeout_error")
+ * @param location - Static code location (e.g., "database.open", "query.execute", "transaction.commit")
+ * @param properties - Optional additional static properties only
+ *
+ * @example
+ * ```typescript
+ * captureError('connection_error', 'database.open');
+ * captureError('query_error', 'sql.execute', { query_type: 'SELECT' });
+ * ```
+ */
+async function captureError(errorType, location, properties) {
+    await capture("error", {
+        error_type: errorType,
+        location,
+        ...properties,
+    });
+}
+/**
+ * Flush any pending events and shutdown the client.
+ */
+async function shutdown() {
+    if (isAnalyticsDisabled()) {
+        return;
+    }
+    try {
+        if (posthogClient) {
+            await posthogClient.shutdown();
+        }
+    }
+    catch {
+        // Ignore shutdown errors
+    }
+}
+// Convenience functions for common events
+/**
+ * Track database open event.
+ */
+async function trackDatabaseOpen(dbPath, mode = "embedded") {
+    await capture("database_opened", {
+        mode,
+        has_custom_path: dbPath !== ":memory:",
+    });
+}
+// Vector search and batch insert tracking removed - only database_opened is tracked
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analytics.js","sourceRoot":"","sources":["../../src/analytics.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SochDB Analytics - Anonymous usage tracking with PostHog\n *\n * This module provides anonymous, privacy-respecting analytics to help\n * improve SochDB. All tracking can be disabled by setting:\n *\n *     SOCHDB_DISABLE_ANALYTICS=true\n *\n * No personally identifiable information (PII) is collected. Only aggregate\n * usage patterns are tracked to understand:\n * - Which features are most used\n * - Performance characteristics\n * - Error patterns for debugging\n *\n * Copyright 2025 Sushanth (https://github.com/sushanthpy)\n * Licensed under the Apache License, Version 2.0\n */\n\nimport { createHash } from \"crypto\";\nimport { hostname, platform, arch, release } from \"os\";\n\n// PostHog configuration\nconst POSTHOG_API_KEY = \"phc_zf0hm6ZmPUJj1pM07Kigqvphh1ClhKX1NahRU4G0bfu\";\nconst POSTHOG_HOST = \"https://us.i.posthog.com\";\n\n// Lazy-loaded PostHog client\nlet posthogClient: any = null;\nlet posthogInitialized = false;\n\n/**\n * Check if analytics is disabled via environment variable.\n * \n * Analytics is disabled when SOCHDB_DISABLE_ANALYTICS is set to 'true', '1', 'yes', or 'on'.\n * \n * @returns true if analytics is disabled\n */\nexport function isAnalyticsDisabled(): boolean {\n  const disableVar = (\n    process.env.SOCHDB_DISABLE_ANALYTICS || \"\"\n  ).toLowerCase();\n  return [\"true\", \"1\", \"yes\", \"on\"].includes(disableVar);\n}\n\n/**\n * Generate a stable anonymous ID for this machine.\n *\n * Uses a hash of machine-specific but non-identifying information.\n * The same machine will always get the same ID, but the ID cannot\n * be reversed to identify the machine.\n */\nfunction getAnonymousId(): string {\n  try {\n    const machineInfo = [\n      hostname(),\n      platform(),\n      arch(),\n      process.getuid?.() ?? \"windows\",\n    ].join(\"|\");\n\n    return createHash(\"sha256\").update(machineInfo).digest(\"hex\").slice(0, 16);\n  } catch {\n    return \"anonymous\";\n  }\n}\n\n/**\n * Lazily initialize PostHog client.\n */\nasync function getPosthogClient(): Promise<any> {\n  if (isAnalyticsDisabled()) {\n    return null;\n  }\n\n  if (posthogInitialized) {\n    return posthogClient;\n  }\n\n  posthogInitialized = true;\n\n  try {\n    // Use require to avoid TypeScript checking the optional module\n    // This allows the SDK to work without posthog-node installed\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    const posthogModule = require(\"posthog-node\");\n    const { PostHog } = posthogModule;\n    posthogClient = new PostHog(POSTHOG_API_KEY, {\n      host: POSTHOG_HOST,\n    });\n    return posthogClient;\n  } catch {\n    // posthog-node not installed or error - analytics disabled\n    return null;\n  }\n}\n\n/**\n * Get the SDK version.\n */\nfunction getSdkVersion(): string {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    const pkg = require(\"../package.json\");\n    return pkg.version || \"unknown\";\n  } catch {\n    return \"unknown\";\n  }\n}\n\nexport interface EventProperties {\n  [key: string]: string | number | boolean | null | undefined;\n}\n\n/**\n * Capture an analytics event.\n *\n * This function is a no-op if:\n * - SOCHDB_DISABLE_ANALYTICS=true\n * - posthog-node package is not installed\n * - Any error occurs (fails silently)\n *\n * @param event - Event name (e.g., \"database_opened\", \"vector_search\")\n * @param properties - Optional event properties\n * @param distinctId - Optional distinct ID (defaults to anonymous machine ID)\n */\nexport async function capture(\n  event: string,\n  properties?: EventProperties,\n  distinctId?: string\n): Promise<void> {\n  if (isAnalyticsDisabled()) {\n    return;\n  }\n\n  try {\n    const client = await getPosthogClient();\n    if (!client) {\n      return;\n    }\n\n    // Build properties with SDK context\n    const eventProperties: EventProperties = {\n      sdk: \"nodejs\",\n      sdk_version: getSdkVersion(),\n      node_version: process.version,\n      os: platform(),\n      arch: arch(),\n      ...properties,\n    };\n\n    client.capture({\n      distinctId: distinctId || getAnonymousId(),\n      event,\n      properties: eventProperties,\n    });\n    \n    // Flush to ensure event is sent immediately\n    await client.flush();\n  } catch {\n    // Never let analytics break user code\n  }\n}\n\n/**\n * Capture an error event for debugging.\n *\n * Only sends static information - no dynamic error messages.\n *\n * @param errorType - Static error category (e.g., \"connection_error\", \"query_error\", \"timeout_error\")\n * @param location - Static code location (e.g., \"database.open\", \"query.execute\", \"transaction.commit\")\n * @param properties - Optional additional static properties only\n *\n * @example\n * ```typescript\n * captureError('connection_error', 'database.open');\n * captureError('query_error', 'sql.execute', { query_type: 'SELECT' });\n * ```\n */\nexport async function captureError(\n  errorType: string,\n  location: string,\n  properties?: EventProperties\n): Promise<void> {\n  await capture(\"error\", {\n    error_type: errorType,\n    location,\n    ...properties,\n  });\n}\n\n/**\n * Flush any pending events and shutdown the client.\n */\nexport async function shutdown(): Promise<void> {\n  if (isAnalyticsDisabled()) {\n    return;\n  }\n\n  try {\n    if (posthogClient) {\n      await posthogClient.shutdown();\n    }\n  } catch {\n    // Ignore shutdown errors\n  }\n}\n\n// Convenience functions for common events\n\n/**\n * Track database open event.\n */\nexport async function trackDatabaseOpen(\n  dbPath: string,\n  mode: string = \"embedded\"\n): Promise<void> {\n  await capture(\"database_opened\", {\n    mode,\n    has_custom_path: dbPath !== \":memory:\",\n  });\n}\n\n// Vector search and batch insert tracking removed - only database_opened is tracked\n"]}