Best LogRocket Session Replay Phone Validation API & Email Verification Integration 2025

// Enhanced LogRocket integration with 1lookup validation
import LogRocket from 'logrocket';

// Initialize LogRocket
LogRocket.init('YOUR_LOGROCKET_APP_ID');

// Enhanced user identification with contact validation for session analytics
window.identifyLogRocketUserWithValidation = async function(userId, userTraits) {
  try {
    // Validate user contact information if present
    if (userTraits.email || userTraits.phone) {
      const validationData = await validateUserContactForLogRocket({
        phone: userTraits.phone,
        email: userTraits.email
      });
      
      // Enhance user traits with validation results
      const enhancedTraits = {
        ...userTraits,
        // Phone validation traits
        phoneValidationStatus: validationData.phone?.is_valid ? 'valid' : 'invalid',
        phoneCarrier: validationData.phone?.carrier_details?.name || '',
        phoneLineType: validationData.phone?.carrier_details?.type || '',
        phoneCountry: validationData.phone?.location_details?.country || '',
        phoneRegion: validationData.phone?.location_details?.region || '',
        phoneRiskLevel: validationData.phone?.risk_assessment?.risk_level || '',
        // Email validation traits
        emailValidationStatus: validationData.email?.is_valid ? 'valid' : 'invalid',
        emailDeliverability: validationData.email?.deliverability?.status || '',
        emailDomainType: validationData.email?.domain_details?.type || '',
        emailRiskLevel: validationData.email?.risk_assessment?.risk_level || '',
        // Session analytics specific enhancements
        userSessionQuality: calculateSessionUserQuality(validationData),
        userSessionTier: determineSessionUserTier(validationData),
        isVerifiedSessionUser: isVerifiedSessionUser(validationData),
        sessionValidationTimestamp: new Date().toISOString(),
        // LogRocket-specific traits
        logRocketValidationVersion: '2025.1',
        sessionAnalyticsSegment: determineSessionAnalyticsSegment(validationData),
        sessionReplayPriority: calculateSessionReplayPriority(validationData),
        errorTrackingTier: calculateErrorTrackingTier(validationData)
      };
      
      // Identify user with enhanced traits in LogRocket
      LogRocket.identify(userId, enhancedTraits);
      
      // Add session-wide context
      LogRocket.addMetadata('userQuality', {
        qualityScore: enhancedTraits.userSessionQuality,
        userTier: enhancedTraits.userSessionTier,
        validationStatus: enhancedTraits.isVerifiedSessionUser ? 'verified' : 'unverified',
        sessionPriority: enhancedTraits.sessionReplayPriority
      });
      
      // Track validation event for session analytics
      LogRocket.track('UserContactValidated', {
        validationType: 'session_analytics_enhancement',
        phoneValid: validationData.phone?.is_valid,
        emailValid: validationData.email?.is_valid,
        qualityScore: enhancedTraits.userSessionQuality,
        sessionSegment: enhancedTraits.sessionAnalyticsSegment
      });
      
      // Add custom tags for session filtering
      LogRocket.getSessionURL((sessionURL) => {
        LogRocket.addMetadata('sessionTags', {
          userQualityTier: enhancedTraits.userSessionTier,
          validationStatus: enhancedTraits.isVerifiedSessionUser ? 'verified' : 'unverified',
          sessionPriority: enhancedTraits.sessionReplayPriority,
          errorTrackingTier: enhancedTraits.errorTrackingTier
        });
      });
      
    } else {
      // Standard identification without validation
      LogRocket.identify(userId, userTraits);
    }
    
  } catch (error) {
    console.error('LogRocket user validation error:', error);
    // Fallback to standard identification
    LogRocket.identify(userId, {
      ...userTraits,
      validationError: true,
      validationErrorMessage: error.message
    });
  }
};

// Contact validation function optimized for session analytics
async function validateUserContactForLogRocket(contactData) {
  const response = await fetch('https://app.1lookup.io/api/v1/validate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_1LOOKUP_API_KEY',
      'Content-Type': 'application/json',
      'X-Integration': 'logrocket-session-analytics'
    },
    body: JSON.stringify({
      ...contactData,
      include_carrier_details: true,
      include_location_details: true,
      include_risk_assessment: true,
      session_analytics_context: true
    })
  });
  
  if (!response.ok) {
    throw new Error(`Session analytics validation failed: ${response.status}`);
  }
  
  return await response.json();
}

// Calculate session analytics-specific user quality score
function calculateSessionUserQuality(validationData) {
  let score = 0;
  
  // Email scoring for session analytics
  if (validationData.email?.is_valid) score += 40;
  if (validationData.email?.deliverability?.status === 'deliverable') score += 15;
  
  // Phone scoring for session analytics
  if (validationData.phone?.is_valid) score += 35;
  if (validationData.phone?.risk_assessment?.risk_level === 'low') score += 10;
  
  return Math.min(100, score);
}

// Determine session user tier
function determineSessionUserTier(validationData) {
  const qualityScore = calculateSessionUserQuality(validationData);
  
  if (qualityScore >= 80) return 'premium_session_user';
  if (qualityScore >= 60) return 'high_value_session_user';
  if (qualityScore >= 40) return 'standard_session_user';
  return 'basic_session_user';
}

// Calculate session replay priority based on user quality
function calculateSessionReplayPriority(validationData) {
  const qualityScore = calculateSessionUserQuality(validationData);
  
  if (qualityScore >= 80) return 'high';
  if (qualityScore >= 60) return 'medium';
  return 'standard';
}

// Calculate error tracking tier based on validation quality
function calculateErrorTrackingTier(validationData) {
  const qualityScore = calculateSessionUserQuality(validationData);
  
  if (qualityScore >= 80) return 'priority';
  if (qualityScore >= 60) return 'standard';
  return 'basic';
}

// Enhanced LogRocket server-side integration with contact validation
const LogRocket = require('logrocket');
const axios = require('axios');

class LogRocketSessionValidator {
  constructor(appId, lookupApiKey) {
    this.appId = appId;
    this.lookupApiKey = lookupApiKey;
    this.sessionCache = new Map();
    LogRocket.init(appId);
  }
  
  async enhanceSessionWithValidation(sessionId, userId, sessionData, userContext) {
    try {
      // Get or validate user contact data
      let userValidation = this.sessionCache.get(userId);
      if (!userValidation) {
        userValidation = await this.validateUserForSession(userContext);
        this.sessionCache.set(userId, userValidation);
      }
      
      // Calculate session quality metrics
      const sessionQuality = this.calculateSessionQuality(sessionData, userValidation);
      
      // Enhanced session context
      const enhancedSessionContext = {
        session_id: sessionId,
        user_id: userId,
        // User validation context
        user_quality_score: userValidation.quality_score,
        user_verification_level: userValidation.verification_level,
        contact_validation_status: userValidation.contact_status,
        user_session_tier: userValidation.session_tier,
        // Session quality metrics
        session_quality_score: sessionQuality.overall_score,
        session_reliability: sessionQuality.reliability,
        session_value_tier: sessionQuality.value_tier,
        is_high_value_session: sessionQuality.is_high_value,
        // Debugging insights
        error_tracking_priority: sessionQuality.error_priority,
        bug_detection_likelihood: sessionQuality.bug_likelihood,
        performance_monitoring_value: sessionQuality.performance_value,
        // User behavior insights
        session_authenticity: sessionQuality.authenticity,
        user_interaction_quality: sessionQuality.interaction_quality,
        debugging_confidence: sessionQuality.debugging_confidence,
        // Geographic and device context
        user_geographic_region: userValidation.region,
        device_trust_score: sessionQuality.device_trust,
        session_anomaly_score: sessionQuality.anomaly_score,
        // LogRocket-specific context
        session_replay_priority: sessionQuality.replay_priority,
        error_analysis_weight: sessionQuality.error_weight,
        performance_optimization_value: sessionQuality.optimization_value
      };
      
      // Add enhanced metadata to LogRocket session
      LogRocket.addMetadata('sessionValidation', enhancedSessionContext);
      
      // Track session enhancement analytics
      LogRocket.track('SessionEnhanced', {
        sessionId: sessionId,
        sessionQuality: sessionQuality.overall_score,
        userTier: userValidation.session_tier,
        debuggingValue: sessionQuality.debugging_value
      });
      
      // Apply session tags for filtering and prioritization
      const sessionTags = this.generateSessionTags(sessionQuality, userValidation);
      sessionTags.forEach(tag => {
        LogRocket.addMetadata('sessionTag', { tag: tag });
      });
      
      // Store enhanced session data
      this.sessionCache.set(sessionId, enhancedSessionContext);
      
      return enhancedSessionContext;
      
    } catch (error) {
      console.error('LogRocket session enhancement error:', error);
      
      // Track error but continue session recording
      LogRocket.addMetadata('sessionEnhancementError', {
        error: error.message,
        timestamp: new Date().toISOString()
      });
      
      return {
        session_id: sessionId,
        enhancement_error: true,
        error_details: error.message
      };
    }
  }
  
  async validateUserForSession(userContext) {
    try {
      const contactData = {
        phone: userContext.phone,
        email: userContext.email
      };
      
      if (!contactData.phone && !contactData.email) {
        return this.getDefaultSessionValidation();
      }
      
      const response = await axios.post('https://app.1lookup.io/api/v1/validate', contactData, {
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json',
          'X-Integration': 'logrocket-server'
        }
      });
      
      const validation = response.data;
      
      return {
        quality_score: this.calculateSessionQualityScore(validation),
        session_tier: this.determineSessionTier(validation),
        verification_level: this.getSessionVerificationLevel(validation),
        contact_status: this.getSessionContactStatus(validation),
        phone_verified: validation.phone?.is_valid,
        email_verified: validation.email?.is_valid,
        fraud_risk_level: validation.fraud_risk_level,
        country: validation.phone?.location_details?.country,
        region: validation.phone?.location_details?.region,
        carrier_type: validation.phone?.carrier_details?.type,
        session_segment: this.determineSessionSegment(validation),
        debugging_reliability: this.calculateDebuggingReliability(validation)
      };
      
    } catch (error) {
      console.error('User session validation error:', error);
      return this.getDefaultSessionValidation();
    }
  }
  
  calculateSessionQuality(sessionData, userValidation) {
    let overallScore = 0;
    let reliability = 0;
    let debuggingValue = 0;
    
    // User quality contribution (40%)
    const userQuality = userValidation.quality_score || 0;
    overallScore = userQuality * 0.4;
    
    // Session behavioral contribution (35%)
    const sessionBehaviorScore = this.calculateSessionBehaviorScore(sessionData);
    overallScore += sessionBehaviorScore * 0.35;
    
    // Error/performance context contribution (25%)
    const contextScore = this.calculateSessionContextScore(sessionData);
    overallScore += contextScore * 0.25;
    
    // Calculate reliability
    reliability = this.calculateSessionReliability(userValidation, sessionData);
    
    // Calculate debugging value
    debuggingValue = this.calculateDebuggingValue(sessionData, userValidation);
    
    return {
      overall_score: Math.min(100, overallScore),
      reliability: Math.min(100, reliability),
      value_tier: this.determineSessionValueTier(debuggingValue),
      is_high_value: overallScore >= 70 && reliability >= 80,
      error_priority: this.calculateErrorPriority(userValidation, sessionData),
      bug_likelihood: this.calculateBugLikelihood(sessionData),
      performance_value: this.calculatePerformanceValue(sessionData, userValidation),
      authenticity: this.calculateSessionAuthenticity(userValidation, sessionData),
      interaction_quality: this.calculateInteractionQuality(sessionData),
      debugging_confidence: this.calculateDebuggingConfidence(userValidation, sessionData),
      device_trust: this.calculateDeviceTrust(sessionData, userValidation),
      anomaly_score: this.calculateSessionAnomalyScore(sessionData),
      replay_priority: this.calculateReplayPriority(overallScore, debuggingValue),
      error_weight: this.calculateErrorWeight(userValidation),
      optimization_value: this.calculateSessionOptimizationValue(overallScore, reliability),
      debugging_value: debuggingValue
    };
  }
  
  generateSessionTags(sessionQuality, userValidation) {
    const tags = [];
    
    // Quality tier tags
    tags.push(`quality-tier-${userValidation.session_tier || 'unknown'}`);
    
    // Session priority tags
    tags.push(`session-priority-${sessionQuality.replay_priority}`);
    
    // Verification status tags
    if (userValidation.phone_verified) tags.push('phone-verified');
    if (userValidation.email_verified) tags.push('email-verified');
    
    // Error tracking tags
    tags.push(`error-priority-${sessionQuality.error_priority}`);
    
    // Performance monitoring tags
    if (sessionQuality.performance_value >= 80) tags.push('high-performance-value');
    
    // Debugging tags
    if (sessionQuality.bug_likelihood >= 70) tags.push('potential-bug');
    if (sessionQuality.debugging_confidence >= 80) tags.push('high-debugging-confidence');
    
    // Geographic tags
    if (userValidation.country) {
      tags.push(`country-${userValidation.country.toLowerCase()}`);
    }
    
    return tags;
  }
}

// Advanced error tracking enhancement with user quality intelligence for LogRocket
class LogRocketErrorTracker {
  constructor(appId, lookupApiKey) {
    this.appId = appId;
    this.lookupApiKey = lookupApiKey;
    this.errorCache = new Map();
    this.userQualityProfiles = new Map();
    LogRocket.init(appId);
  }
  
  async trackErrorWithValidation(error, userId, errorContext, userContext) {
    try {
      // Get user validation data for error analysis
      const userValidation = await this.getUserValidationForError(userId, userContext);
      
      // Calculate error quality and impact metrics
      const errorQuality = this.calculateErrorQuality(error, errorContext, userValidation);
      
      // Enhanced error tracking data
      const enhancedErrorData = {
        error_id: this.generateErrorId(error),
        user_id: userId,
        error_message: error.message,
        error_stack: error.stack,
        error_timestamp: new Date().toISOString(),
        // User validation context
        user_quality_score: userValidation.quality_score,
        user_verification_level: userValidation.verification_level,
        user_session_tier: userValidation.session_tier,
        // Error quality metrics
        error_quality_score: errorQuality.score,
        error_impact_level: errorQuality.impact_level,
        error_priority: errorQuality.priority,
        error_debugging_confidence: errorQuality.debugging_confidence,
        // User impact analysis
        affected_user_quality: errorQuality.affected_user_quality,
        error_user_impact_score: errorQuality.user_impact_score,
        user_experience_degradation: errorQuality.ux_degradation,
        // Error context enhancement
        error_reproducibility_score: errorQuality.reproducibility_score,
        error_severity_adjusted: errorQuality.severity_adjusted,
        error_business_impact: errorQuality.business_impact,
        // Geographic and device context
        user_geographic_region: userValidation.region,
        device_error_trust: errorQuality.device_trust,
        error_anomaly_score: errorQuality.anomaly_score,
        // LogRocket-specific enhancements
        session_replay_value: errorQuality.session_replay_value,
        error_analysis_weight: errorQuality.analysis_weight,
        debugging_optimization_priority: errorQuality.debugging_priority
      };
      
      // Capture error with enhanced context in LogRocket
      LogRocket.captureException(error, {
        tags: {
          userQualityTier: userValidation.session_tier,
          errorPriority: errorQuality.priority,
          userVerified: userValidation.phone_verified || userValidation.email_verified
        },
        extra: enhancedErrorData,
        user: {
          id: userId,
          qualityScore: userValidation.quality_score,
          verificationLevel: userValidation.verification_level
        }
      });
      
      // Track error quality analytics
      LogRocket.track('ErrorQualityAnalyzed', {
        errorId: enhancedErrorData.error_id,
        errorQuality: errorQuality.score,
        userTier: userValidation.session_tier,
        impactLevel: errorQuality.impact_level,
        debuggingPriority: errorQuality.debugging_priority
      });
      
      // Update error tracking profile
      await this.updateErrorTrackingProfile(userId, enhancedErrorData);
      
      // Trigger error response workflow if high priority
      if (errorQuality.priority === 'critical' && userValidation.quality_score >= 80) {
        await this.triggerHighPriorityErrorWorkflow(enhancedErrorData);
      }
      
      return enhancedErrorData;
      
    } catch (validationError) {
      console.error('Error validation tracking error:', validationError);
      
      // Fallback error tracking
      LogRocket.captureException(error, {
        tags: { validationError: true },
        extra: { validationErrorMessage: validationError.message }
      });
      
      return { error: validationError.message };
    }
  }
  
  calculateErrorQuality(error, errorContext, userValidation) {
    let score = 0;
    let impactLevel = 'low';
    let priority = 'standard';
    
    // User quality impact on error priority (50%)
    const userQuality = userValidation.quality_score || 0;
    score = userQuality * 0.5;
    
    // Error severity impact (30%)
    const severityScore = this.calculateErrorSeverityScore(error, errorContext);
    score += severityScore * 0.3;
    
    // Error context impact (20%)
    const contextScore = this.calculateErrorContextScore(errorContext);
    score += contextScore * 0.2;
    
    // Determine impact level
    if (score >= 80 && userQuality >= 70) impactLevel = 'critical';
    else if (score >= 60) impactLevel = 'high';
    else if (score >= 40) impactLevel = 'medium';
    
    // Determine priority
    if (impactLevel === 'critical') priority = 'critical';
    else if (impactLevel === 'high' && userQuality >= 60) priority = 'high';
    else if (impactLevel === 'medium') priority = 'medium';
    
    return {
      score: Math.min(100, score),
      impact_level: impactLevel,
      priority: priority,
      debugging_confidence: this.calculateErrorDebuggingConfidence(userValidation, error),
      affected_user_quality: userQuality,
      user_impact_score: this.calculateUserImpactScore(userValidation, error),
      ux_degradation: this.calculateUXDegradation(error, userValidation),
      reproducibility_score: this.calculateErrorReproducibilityScore(error, errorContext),
      severity_adjusted: this.calculateSeverityAdjusted(error, userValidation),
      business_impact: this.calculateBusinessImpact(error, userValidation),
      device_trust: this.calculateDeviceTrust(errorContext, userValidation),
      anomaly_score: this.calculateErrorAnomalyScore(error),
      session_replay_value: this.calculateSessionReplayValue(error, userValidation),
      analysis_weight: this.calculateErrorAnalysisWeight(userValidation),
      debugging_priority: this.calculateDebuggingPriority(score, userQuality)
    };
  }
  
  async getUserValidationForError(userId, userContext) {
    // Check cache first for performance
    if (this.userQualityProfiles.has(userId)) {
      return this.userQualityProfiles.get(userId);
    }
    
    try {
      const contactData = {
        phone: userContext.phone,
        email: userContext.email
      };
      
      if (!contactData.phone && !contactData.email) {
        return this.getDefaultErrorValidation();
      }
      
      const response = await axios.post('https://app.1lookup.io/api/v1/validate', contactData, {
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json',
          'X-Integration': 'logrocket-error-tracking'
        }
      });
      
      const validation = response.data;
      
      const validationProfile = {
        quality_score: this.calculateErrorUserQualityScore(validation),
        session_tier: this.determineErrorSessionTier(validation),
        verification_level: this.getErrorVerificationLevel(validation),
        contact_status: this.getErrorContactStatus(validation),
        phone_verified: validation.phone?.is_valid,
        email_verified: validation.email?.is_valid,
        fraud_risk_level: validation.fraud_risk_level,
        region: validation.phone?.location_details?.region,
        country: validation.phone?.location_details?.country,
        debugging_reliability: this.calculateDebuggingReliability(validation)
      };
      
      // Cache for future error tracking
      this.userQualityProfiles.set(userId, validationProfile);
      
      return validationProfile;
      
    } catch (error) {
      console.error('User validation for error tracking error:', error);
      return this.getDefaultErrorValidation();
    }
  }
}