humanbehavior-js 0.1.2 → 0.1.4

package/dist/types/index.d.ts

@@ -119,6 +119,14 @@ declare class HumanBehaviorTracker {
         ingestionUrl?: string;
         logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
         redactFields?: string[];
+        enableAutomaticTracking?: boolean;
+        automaticTrackingOptions?: {
+            trackButtons?: boolean;
+            trackLinks?: boolean;
+            trackForms?: boolean;
+            includeText?: boolean;
+            includeClasses?: boolean;
+        };
     }): HumanBehaviorTracker;
     constructor(apiKey: string | undefined, ingestionUrl?: string);
     private init;
@@ -139,6 +147,22 @@ declare class HumanBehaviorTracker {
      * Track a custom event (PostHog-style)
      */
     customEvent(eventName: string, properties?: Record<string, any>): Promise<void>;
+    /**
+     * Setup automatic tracking for buttons, links, and forms
+     */
+    private setupAutomaticTracking;
+    /**
+     * Setup automatic button tracking
+     */
+    private setupAutomaticButtonTracking;
+    /**
+     * Setup automatic link tracking
+     */
+    private setupAutomaticLinkTracking;
+    /**
+     * Setup automatic form tracking
+     */
+    private setupAutomaticFormTracking;
     /**
      * Cleanup navigation tracking
      */
@@ -252,6 +276,11 @@ declare class HumanBehaviorAPI {
     sendUserData(userId: string, userData: Record<string, any>, sessionId: string): Promise<any>;
     sendUserAuth(userId: string, userData: Record<string, any>, sessionId: string, authFields: string[]): Promise<any>;
     sendBeaconEvents(events: any[], sessionId: string): void;
+    sendCustomEvent(sessionId: string, eventName: string, eventProperties?: Record<string, any>): Promise<any>;
+    sendCustomEventBatch(sessionId: string, events: Array<{
+        eventName: string;
+        eventProperties?: Record<string, any>;
+    }>): Promise<any>;
 }
 
 declare enum LogLevel {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanbehavior-js",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "SDK for HumanBehavior session and event recording",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/api.ts

@@ -41,29 +41,41 @@ export class HumanBehaviorAPI {
             referrer = document.referrer;
         }
 
-        const response = await fetch(`${this.baseUrl}/api/ingestion/init`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Referer': referrer || ''
-            },
-            body: JSON.stringify({
-                sessionId: sessionId,
-                endUserId: userId,
-                entryURL: entryURL,
-                referrer: referrer
-            })
-        });
+        console.log('API init called with:', { sessionId, userId, entryURL, referrer, baseUrl: this.baseUrl });
 
-        if (!response.ok) {
-            throw new Error(`Failed to initialize ingestion: ${response.statusText}`);
-        } 
+        try {
+            const response = await fetch(`${this.baseUrl}/api/ingestion/init`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Referer': referrer || ''
+                },
+                body: JSON.stringify({
+                    sessionId: sessionId,
+                    endUserId: userId,
+                    entryURL: entryURL,
+                    referrer: referrer
+                })
+            });
+
+            console.log('API init response status:', response.status);
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error('API init failed:', response.status, errorText);
+                throw new Error(`Failed to initialize ingestion: ${response.statusText} - ${errorText}`);
+            } 
 
-        const responseJson = await response.json();
-        return {
-            sessionId: responseJson.sessionId,
-            endUserId: responseJson.endUserId
+            const responseJson = await response.json();
+            console.log('API init success:', responseJson);
+            return {
+                sessionId: responseJson.sessionId,
+                endUserId: responseJson.endUserId
+            }
+        } catch (error) {
+            console.error('API init error:', error);
+            throw error;
         }
     }
 
@@ -219,4 +231,55 @@ export class HumanBehaviorAPI {
             data
         );
     }
+
+    async sendCustomEvent(sessionId: string, eventName: string, eventProperties?: Record<string, any>) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    sessionId: sessionId,
+                    eventName: eventName,
+                    eventProperties: eventProperties || {}
+                })
+            });
+            
+            if (!response.ok) {
+                throw new Error(`Failed to send custom event: ${response.statusText}`);
+            }
+            
+            return await response.json();
+        } catch (error) {
+            logError('Error sending custom event:', error);
+            throw error;
+        }
+    }
+
+    async sendCustomEventBatch(sessionId: string, events: Array<{ eventName: string; eventProperties?: Record<string, any> }>) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent/batch`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    sessionId: sessionId,
+                    events: events
+                })
+            });
+            
+            if (!response.ok) {
+                throw new Error(`Failed to send custom event batch: ${response.statusText}`);
+            }
+            
+            return await response.json();
+        } catch (error) {
+            logError('Error sending custom event batch:', error);
+            throw error;
+        }
+    }
 }

package/src/tracker.ts

@@ -58,6 +58,14 @@ export class HumanBehaviorTracker {
         ingestionUrl?: string;
         logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
         redactFields?: string[];
+        enableAutomaticTracking?: boolean;
+        automaticTrackingOptions?: {
+            trackButtons?: boolean;
+            trackLinks?: boolean;
+            trackForms?: boolean;
+            includeText?: boolean;
+            includeClasses?: boolean;
+        };
     }): HumanBehaviorTracker {
         // Return existing instance if already initialized
         if (isBrowser && window.__humanBehaviorGlobalTracker) {
@@ -78,6 +86,11 @@ export class HumanBehaviorTracker {
             tracker.setRedactedFields(options.redactFields);
         }
 
+        // Setup automatic tracking if enabled
+        if (options?.enableAutomaticTracking !== false) {
+            tracker.setupAutomaticTracking(options?.automaticTrackingOptions);
+        }
+
         // Test connection (non-blocking)
         if (isBrowser) {
             const testUrl = tracker.api['baseUrl'] + '/api/health';
@@ -101,7 +114,8 @@ export class HumanBehaviorTracker {
         }
         
         // Initialize API
-        const defaultIngestionUrl = 'http://3.137.217.33:3000'; // AWS Development Server
+        //const defaultIngestionUrl = 'http://3.137.217.33:3000'; // AWS Development Server
+        const defaultIngestionUrl = 'http://ingestion-server-alb-1823866402.us-east-2.elb.amazonaws.com'; // ALB
         this.api = new HumanBehaviorAPI({ 
             apiKey: apiKey,
             ingestionUrl: ingestionUrl || defaultIngestionUrl
@@ -330,32 +344,201 @@ export class HumanBehaviorTracker {
         if (!this.initialized) return;
 
         try {
-            const customEventData = {
-                eventName: eventName,
-                properties: properties || {},
-                timestamp: new Date().toISOString(),
-                url: window.location.href,
-                pathname: window.location.pathname
-            };
-
-            // Add custom event to the main event stream
-            await this.addEvent({
-                type: 5, // Custom event type
-                data: {
-                    payload: {
-                        eventType: 'custom',
-                        ...customEventData
-                    }
-                },
-                timestamp: Date.now()
-            });
+            // Send custom event directly to the API
+            await this.api.sendCustomEvent(this.sessionId, eventName, properties);
             
             logDebug(`Custom event tracked: ${eventName}`, properties);
         } catch (error) {
             logError('Failed to track custom event:', error);
+            
+            // Fallback: add to event stream if direct API call fails
+            try {
+                const customEventData = {
+                    eventName: eventName,
+                    properties: properties || {},
+                    timestamp: new Date().toISOString(),
+                    url: window.location.href,
+                    pathname: window.location.pathname
+                };
+
+                await this.addEvent({
+                    type: 5, // Custom event type
+                    data: {
+                        payload: {
+                            eventType: 'custom',
+                            ...customEventData
+                        }
+                    },
+                    timestamp: Date.now()
+                });
+                
+                logDebug(`Custom event added to event stream as fallback: ${eventName}`);
+            } catch (fallbackError) {
+                logError('Failed to add custom event to event stream as fallback:', fallbackError);
+            }
         }
     }
 
+    /**
+     * Setup automatic tracking for buttons, links, and forms
+     */
+    private setupAutomaticTracking(options?: {
+        trackButtons?: boolean;
+        trackLinks?: boolean;
+        trackForms?: boolean;
+        includeText?: boolean;
+        includeClasses?: boolean;
+    }): void {
+        if (!isBrowser) return;
+
+        const config = {
+            trackButtons: options?.trackButtons !== false,
+            trackLinks: options?.trackLinks !== false,
+            trackForms: options?.trackForms !== false,
+            includeText: options?.includeText !== false,
+            includeClasses: options?.includeClasses || false
+        };
+
+        logDebug('Setting up automatic tracking with config:', config);
+
+        // Setup button tracking
+        if (config.trackButtons) {
+            this.setupAutomaticButtonTracking(config);
+        }
+
+        // Setup link tracking
+        if (config.trackLinks) {
+            this.setupAutomaticLinkTracking(config);
+        }
+
+        // Setup form tracking
+        if (config.trackForms) {
+            this.setupAutomaticFormTracking(config);
+        }
+    }
+
+    /**
+     * Setup automatic button tracking
+     */
+    private setupAutomaticButtonTracking(config: {
+        includeText?: boolean;
+        includeClasses?: boolean;
+    }): void {
+        document.addEventListener('click', async (event) => {
+            const target = event.target as HTMLElement;
+            
+            // Track button clicks
+            if (target.tagName === 'BUTTON' || target.closest('button')) {
+                const button = target.tagName === 'BUTTON'
+                    ? target as HTMLButtonElement
+                    : target.closest('button') as HTMLButtonElement;
+                
+                const properties: Record<string, any> = {
+                    buttonId: button.id || null,
+                    buttonType: button.type || 'button',
+                    page: window.location.pathname,
+                    timestamp: Date.now()
+                };
+
+                if (config.includeText) {
+                    properties.buttonText = button.textContent?.trim() || null;
+                }
+
+                if (config.includeClasses) {
+                    properties.buttonClass = button.className || null;
+                }
+
+                // Remove null values
+                Object.keys(properties).forEach(key => {
+                    if (properties[key] === null) {
+                        delete properties[key];
+                    }
+                });
+
+                await this.customEvent('button_clicked', properties);
+            }
+        });
+    }
+
+    /**
+     * Setup automatic link tracking
+     */
+    private setupAutomaticLinkTracking(config: {
+        includeText?: boolean;
+        includeClasses?: boolean;
+    }): void {
+        document.addEventListener('click', async (event) => {
+            const target = event.target as HTMLElement;
+            
+            // Track link clicks
+            if (target.tagName === 'A' || target.closest('a')) {
+                const link = target.tagName === 'A'
+                    ? target as HTMLAnchorElement
+                    : target.closest('a') as HTMLAnchorElement;
+                
+                const properties: Record<string, any> = {
+                    linkUrl: link.href || null,
+                    linkId: link.id || null,
+                    linkTarget: link.target || null,
+                    page: window.location.pathname,
+                    timestamp: Date.now()
+                };
+
+                if (config.includeText) {
+                    properties.linkText = link.textContent?.trim() || null;
+                }
+
+                if (config.includeClasses) {
+                    properties.linkClass = link.className || null;
+                }
+
+                // Remove null values
+                Object.keys(properties).forEach(key => {
+                    if (properties[key] === null) {
+                        delete properties[key];
+                    }
+                });
+
+                await this.customEvent('link_clicked', properties);
+            }
+        });
+    }
+
+    /**
+     * Setup automatic form tracking
+     */
+    private setupAutomaticFormTracking(config: {
+        includeText?: boolean;
+        includeClasses?: boolean;
+    }): void {
+        document.addEventListener('submit', async (event) => {
+            const form = event.target as HTMLFormElement;
+            const formData = new FormData(form);
+            
+            const properties: Record<string, any> = {
+                formId: form.id || null,
+                formAction: form.action || null,
+                formMethod: form.method || 'get',
+                fields: Array.from(formData.keys()),
+                page: window.location.pathname,
+                timestamp: Date.now()
+            };
+
+            if (config.includeClasses) {
+                properties.formClass = form.className || null;
+            }
+
+            // Remove null values
+            Object.keys(properties).forEach(key => {
+                if (properties[key] === null) {
+                    delete properties[key];
+                }
+            });
+
+            await this.customEvent('form_submitted', properties);
+        });
+    }
+
     /**
      * Cleanup navigation tracking
      */