@vrplatform/log 2.0.0-alpha.8 → 2.0.0

package/src/log/baselog.ts

@@ -1,9 +1,8 @@
-import { getCorrelationId, requestToContext } from './common';
-import type { BaseLog, ChildLogOptions, Log } from './type';
-export * from './type';
 import { Axiom } from '@axiomhq/js';
 import { serializeError } from 'serialize-error';
 import { logger } from './color';
+import { getCorrelationId, requestToContext } from './common';
+import type { BaseLog, ChildLogOptions, Log } from './type';
 
 let lastMessageTimestamp: number | undefined = undefined;
 

package/src/log/common.ts

@@ -1,17 +1,4 @@
-import type { RequestLike } from './type';
-
-// Headers
-export const CONNECTION_ID_HEADER = 'X-Connection-ID';
-export const WORKFLOW_ID_HEADER = 'X-Workflow-ID';
-export const TASK_QUEUE_HEADER = 'X-Task-Queue';
-export const CORRELATION_ID_HEADER = 'X-Correlation-ID';
-export const VERIFICATION_HEADER = 'X-Verification-Key';
-
-// Env
-export const AXIOM_AUTH_TOKEN_ENV = 'AXIOM_AUTH_TOKEN';
-export const AXIOM_ORG_ID_ENV = 'AXIOM_ORG_ID';
-export const AXIOM_DATASET_ENV = 'AXIOM_DATASET';
-export const LOG_ENV = 'LOG';
+import { CORRELATION_ID_HEADER, type RequestLike } from './type';
 
 export const requestHeadersToCapture = ['user-agent'];
 

package/src/log/index.ts

@@ -1,16 +1,16 @@
 import { createBaseLog } from './baselog';
+import { getCorrelationId, getEnvironment, requestToContext } from './common';
 import {
   AXIOM_AUTH_TOKEN_ENV,
   AXIOM_DATASET_ENV,
   AXIOM_ORG_ID_ENV,
   LOG_ENV,
+  type LogBindings,
+  type RequestLike,
   TASK_QUEUE_HEADER,
   WORKFLOW_ID_HEADER,
-  getCorrelationId,
-  getEnvironment,
-  requestToContext,
-} from './common';
-import type { RequestLike, WorkerLog } from './type';
+  type WorkerLog,
+} from './type';
 
 export * from './common';
 export * from './baselog';
@@ -37,7 +37,7 @@ export function useLog({
   correlationId?: string;
   version?: string;
   dataset?: string;
-  env?: Record<string, any>;
+  env?: LogBindings;
   context?: Record<string, any>;
   executionContext?: {
     waitUntil(promise: Promise<any>): void;

package/src/log/type.ts

@@ -1,3 +1,26 @@
+// Headers
+export const CONNECTION_ID_HEADER = 'X-Connection-ID';
+export const WORKFLOW_ID_HEADER = 'X-Workflow-ID';
+export const TASK_QUEUE_HEADER = 'X-Task-Queue';
+export const CORRELATION_ID_HEADER = 'X-Correlation-ID';
+export const VERIFICATION_HEADER = 'X-Verification-Key';
+
+// Env
+export const AXIOM_AUTH_TOKEN_ENV = 'AXIOM_AUTH_TOKEN';
+export const AXIOM_ORG_ID_ENV = 'AXIOM_ORG_ID';
+export const AXIOM_DATASET_ENV = 'AXIOM_DATASET';
+export const LOG_ENV = 'LOG';
+
+export type LogBindings = {
+  [LOG_ENV]?: string;
+  [AXIOM_AUTH_TOKEN_ENV]?: string;
+  [AXIOM_ORG_ID_ENV]?: string;
+  [AXIOM_DATASET_ENV]?: string;
+  NODE_ENV?: string;
+  IS_LOCAL_DEV?: string;
+  MACHINE_NAME?: string;
+};
+
 export type LogFn = (
   message: any,
   additionalContext?: Record<string, any>

package/src/tracking/index.ts

@@ -1,22 +1,53 @@
 import { Analytics } from '@june-so/analytics-node';
 import { PostHog } from 'posthog-node';
-import { useLog } from '../log';
+import { type LogBindings, type WorkerLog, useLog } from '../log';
 import { useIntercom } from './intercom';
+import type { TrackingEvent } from './types';
 
-const E2E_TEST_USERS = [
-  '9e7dfc88-503c-4222-9905-9116169d2203', // lars+checkly@finalytic.co
-  '113d73d8-ee21-46b7-a12a-a74f632401ca', // e2e-invite-member@finalytic.io
-  '917b7c4e-cb03-491c-9e94-d33a5bdeca05', // e2e-invite-owner@finalytic.io
-  'ec8e5572-74d0-4ae6-af73-bca8db9a27e9', // e2e-sign-up@finalytic.io
-];
-const E2E_TEST_TEAMS = [
-  'c4fd21b4-8447-43a2-bdcb-f06a85a935ad', // VRP Automated Testing
-  '8f21060e-afe6-410a-b2f4-00a3caa20786', // test_company_xxxx
-];
-
-const isTest = (userId: string, groupId?: string) =>
-  E2E_TEST_USERS.includes(userId) ||
-  (groupId && E2E_TEST_TEAMS.includes(groupId));
+export * from './types';
+
+const E2E_TEST_USERS = {
+  'e2e-invite-member@finalytic.io': '113d73d8-ee21-46b7-a12a-a74f632401ca',
+  'e2e-invite-owner@finalytic.io': '917b7c4e-cb03-491c-9e94-d33a5bdeca05',
+  'e2e-sign-up@finalytic.io': 'ec8e5572-74d0-4ae6-af73-bca8db9a27e9',
+  'lars+checkly@finalytic.co': '9e7dfc88-503c-4222-9905-9116169d2203',
+};
+
+const E2E_TEST_TEAMS = {
+  'VRP Automated Testing': 'c4fd21b4-8447-43a2-bdcb-f06a85a935ad',
+  test_company_xxxx: '8f21060e-afe6-410a-b2f4-00a3caa20786',
+};
+
+export const isTest = (userId: string, groupId?: string, userEmail?: string) =>
+  Object.values(E2E_TEST_USERS).includes(userId) ||
+  (groupId && Object.values(E2E_TEST_TEAMS).includes(groupId)) ||
+  (userEmail && Object.keys(E2E_TEST_USERS).includes(userEmail));
+
+const camelToSnakeCase = (str: string) =>
+  str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+
+// todo: move to utils
+export const convertKeysToSnakeCase = (obj?: Record<string, any>) => {
+  const result: Record<string, any> = {};
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      const snakeKey = camelToSnakeCase(key);
+      if (
+        typeof obj[key] === 'object' &&
+        !Array.isArray(obj[key]) &&
+        obj[key] !== null
+      ) {
+        result[snakeKey] = convertKeysToSnakeCase(obj[key]);
+      } else {
+        result[snakeKey] = obj[key];
+      }
+    }
+  }
+
+  return result;
+};
 
 export type TrackingProps = {
   name: string;
@@ -25,10 +56,28 @@ export type TrackingProps = {
     INTERCOM_TOKEN?: string;
     JUNESO_TOKEN?: string;
     POSTHOG_TOKEN?: string;
-  };
+  } & LogBindings;
+  debugging?: boolean;
 };
 export type Tracking = ReturnType<typeof useTracking>;
 
+export type TrackProps = OptionalUser<{
+  groupId: string;
+  event: TrackingEvent;
+  properties: Record<string, string | number | boolean | null | undefined>;
+  timestamp?: Date;
+}>;
+export type IdentifyProps = {
+  userId: string;
+  traits: Record<string, string | number | boolean | null | undefined>;
+  disableGeoip?: boolean;
+  timestamp?: Date;
+};
+export type GroupProps = OptionalUser<{
+  groupId: string;
+  traits?: Record<string, string | number | boolean | null | undefined>;
+  timestamp?: Date;
+}>;
 type OptionalUser<T> = T &
   (
     | { userId: string; anonymousId?: string }
@@ -41,12 +90,24 @@ type OptionalUser<T> = T &
 export const useTracking = (
   { dataset, env, name }: TrackingProps,
   isDev?: boolean
-) => {
-  const axiom = useLog({ name, dataset, env });
-  const intercom = env.INTERCOM_TOKEN
-    ? useIntercom(env.INTERCOM_TOKEN, axiom)
+): {
+  track: (props: TrackProps) => Promise<void>;
+  identify: (props: IdentifyProps) => Promise<void>;
+  group: (props: GroupProps) => Promise<void>;
+  shutdown: () => Promise<any>;
+  log: WorkerLog;
+  june?: Analytics;
+  _intercom?: ReturnType<typeof useIntercom>;
+  posthog?: PostHog;
+} => {
+  const log = useLog({ name, dataset, env });
+
+  const _intercom = env.INTERCOM_TOKEN
+    ? useIntercom(env.INTERCOM_TOKEN, log)
     : undefined;
-  const juneso = env.JUNESO_TOKEN ? new Analytics(env.JUNESO_TOKEN) : undefined;
+
+  const june = env.JUNESO_TOKEN ? new Analytics(env.JUNESO_TOKEN) : undefined;
+
   const posthog = env.POSTHOG_TOKEN
     ? new PostHog(env.POSTHOG_TOKEN, {
         host: 'https://app.posthog.com',
@@ -57,112 +118,133 @@ export const useTracking = (
     // General
     track: async ({
       userId,
+      anonymousId,
       groupId,
       event,
       properties,
-    }: {
-      userId: string;
-      groupId: string;
-      event: string;
-      properties: Record<string, any>;
-    }) => {
-      if (isDev || isTest(userId, groupId)) return;
-
-      posthog?.capture({
-        distinctId: userId,
-        event,
-        groups: {
-          tenant: groupId,
-        },
-        properties,
-      });
-      juneso?.track(
-        {
-          userId,
+      timestamp,
+    }: TrackProps) => {
+      if (isDev || isTest(userId || anonymousId || '', groupId)) return;
+
+      if (anonymousId) {
+        posthog?.capture({
+          distinctId: anonymousId,
           event,
-          properties,
-          context: { groupId },
-        },
-        (err) => {
-          if (err) console.error(err);
-        }
-      );
+          groups: {
+            tenant: groupId,
+          },
+          timestamp,
+          properties: convertKeysToSnakeCase(properties),
+        });
+        june?.track(
+          {
+            anonymousId,
+            event,
+            properties,
+            timestamp,
+            context: { groupId },
+          },
+          (err) => {
+            if (err) console.error(err);
+          }
+        );
 
-      try {
-        await intercom?.trackEvent({
-          user_id: userId,
-          event_name: event,
-          metadata: properties,
+        // no intercom for anonymous
+      } else if (userId) {
+        posthog?.capture({
+          distinctId: userId,
+          event,
+          groups: {
+            tenant: groupId,
+          },
+          timestamp,
+          properties: convertKeysToSnakeCase(properties),
         });
-      } catch (error: any) {
-        console.error(error);
+        june?.track(
+          {
+            userId,
+            event,
+            properties,
+            timestamp,
+            context: { groupId },
+          },
+          (err) => {
+            if (err) console.error(err);
+          }
+        );
+
+        try {
+          await _intercom?.trackEvent({
+            user_id: userId,
+            event_name: event,
+            metadata: properties,
+          });
+        } catch (error: any) {
+          console.error(error);
+        }
       }
     },
-    identify: ({
+    identify: async ({
       traits,
       userId,
       disableGeoip,
-    }: {
-      userId: string;
-      traits: Record<string, any>;
-      disableGeoip?: boolean;
-    }) => {
+      timestamp,
+    }: IdentifyProps) => {
       if (isDev || isTest(userId)) return;
 
       posthog?.identify({
         distinctId: userId,
-        properties: traits,
+        properties: convertKeysToSnakeCase(traits),
         disableGeoip,
       });
-      juneso?.identify(
+      june?.identify(
         {
           userId,
           traits,
+          timestamp,
         },
         (err) => {
           if (err) console.error(err);
         }
       );
     },
-    group: ({
+    group: async ({
       traits,
       groupId,
       userId,
       anonymousId,
-    }: OptionalUser<{
-      groupId: string;
-      traits?: Record<string, any>;
-    }>) => {
+      timestamp,
+    }: GroupProps) => {
       if (isDev || isTest(userId || anonymousId || '', groupId)) return;
 
-      posthog?.groupIdentify({
-        groupKey: groupId,
-        groupType: 'tenant',
-        properties: traits,
-        distinctId: userId,
-      });
-      if (anonymousId)
-        juneso?.group({ anonymousId, groupId, traits }, (err) =>
-          console.error(err)
-        );
-      else if (userId)
-        juneso?.group({ userId, groupId, traits }, (err) => {
+      if (anonymousId) {
+        posthog?.groupIdentify({
+          groupKey: groupId,
+          groupType: 'tenant',
+          properties: convertKeysToSnakeCase(traits),
+          distinctId: anonymousId,
+        });
+        june?.group({ anonymousId, groupId, traits, timestamp }, (err) => {
           if (err) console.error(err);
         });
+      } else if (userId) {
+        posthog?.groupIdentify({
+          groupKey: groupId,
+          groupType: 'tenant',
+          properties: convertKeysToSnakeCase(traits),
+          distinctId: userId,
+        });
+        june?.group({ userId, groupId, traits, timestamp }, (err) => {
+          if (err) console.error(err);
+        });
+      }
     },
     shutdown: async () =>
-      Promise.all([
-        posthog?.shutdown(),
-        juneso?.closeAndFlush(),
-        axiom?.flush(),
-      ]),
-    // Posthog specific
-    alias: posthog?.alias,
-    isFeatureEnabled: posthog?.isFeatureEnabled,
-    // export intercom and axiom
-    intercom,
+      Promise.all([posthog?.shutdown(), june?.closeAndFlush(), log?.flush()]),
+    // export dependencies
+    _intercom,
     posthog,
-    june: juneso,
-    log: axiom,
+    june,
+    log,
   };
 };

package/src/tracking/intercom.ts

@@ -113,6 +113,7 @@ export class IntercomAPI {
       email?: string;
       name?: string;
       custom_attributes: Record<string, any>;
+      [key: string]: any;
     };
   }) {
     return await this.fetch(`/contacts/${contactId}`, {
@@ -217,7 +218,7 @@ export class IntercomAPI {
     tenantId: string;
     data: {
       name: string;
-      remote_created_at: string;
+      remote_created_at: number;
       custom_attributes: Record<string, any>;
     };
   }) {

package/src/tracking/types.ts

@@ -0,0 +1,97 @@
+type AuthEvent =
+  | 'account_signin_completed'
+  | 'account_signup_code_requested'
+  | 'account_signup_code_completed'
+  | 'account_signup_code_failed'
+  | 'account_signup_completed'
+  | 'account_password_reset_requested'
+  | 'account_password_reset_failed'
+  | 'account_password_reset_completed'
+  | 'account_invitation_accepted'
+  | 'account_signed_out';
+
+type TeamEvent =
+  | 'team_added'
+  | 'team_info_updated'
+  | 'team_deleted'
+  | 'team_member_removed';
+
+type ConnectionEvent =
+  | 'connection_created'
+  | 'connection_reconnected'
+  | 'connection_deleted'
+  | 'connection_requested';
+
+type OwnershipEvent =
+  | 'ownership_created'
+  | 'ownership_updated'
+  | 'ownership_deleted';
+
+type OwnerEvent =
+  | 'owner_created'
+  | 'owner_updated'
+  | 'owner_deleted'
+  | 'owner_tax_info_modal_opened'
+  | 'owner_tax_info_modal_submitted';
+
+type SetupEvent =
+  | 'setup_classes_set'
+  | 'setup_accounting_version_completed'
+  | 'setup_accounting_config_completed'
+  | 'setup_owner_imported'
+  | 'setup_listing_imported';
+
+type AutomationEvent =
+  | 'automation_created'
+  | 'automation_updated'
+  | 'automation_deleted';
+
+type TaxStatementEvent =
+  | 'tax_statement_preview_opened'
+  | 'tax_statement_downloaded';
+
+type GLOwnerStatementEvent =
+  | 'gl_owner_statement_preview_opened'
+  | 'gl_owner_statement_downloaded';
+
+type HyperlineEvent =
+  | 'hyperline_invoice_ready'
+  | 'hyperline_invoice_settled'
+  | 'hyperline_trial_started'
+  | 'hyperline_trial_ended'
+  | 'hyperline_subscription_activated'
+  | 'hyperline_subscription_cancelled'
+  | 'hyperline_subscription_created'
+  | 'hyperline_subscription_errored'
+  | 'hyperline_subscription_paused'
+  | 'hyperline_subscription_voided'
+  | 'hyperline_subscription_charged'
+  | 'hyperline_customer_created'
+  | 'hyperline_customer_updated'
+  | 'hyperline_payment_method_created'
+  | 'hyperline_payment_method_errored'
+  | 'hyperline_payment_method_deleted';
+
+type ListingEvent = 'listing_activated' | 'listing_deactivated';
+
+type ReportEvent = 'listings_reported';
+
+type UserEvent = 'update_refresh_accepted' | 'owner_statement_opened';
+
+type TestEvent = 'test_event' | 'test_error';
+
+export type TrackingEvent =
+  | AuthEvent
+  | TeamEvent
+  | ConnectionEvent
+  | OwnershipEvent
+  | OwnerEvent
+  | SetupEvent
+  | AutomationEvent
+  | TaxStatementEvent
+  | GLOwnerStatementEvent
+  | HyperlineEvent
+  | UserEvent
+  | ListingEvent
+  | ReportEvent
+  | TestEvent;