New Relic Browser監視入門 第9.1章 - ブラウザ監視の重要性とReal User Monitoring ​

// 状況：商品ページの読み込みが遅い
// サーバー監視：「全て正常」
// Browser監視で発見した実際の問題：

// 問題のあったコード（読み込み時間3.5秒）
function loadProductPage(productId) {
  // 🚨 問題1: 複数の大きな画像を同時読み込み
  const images = [
    '/images/product-' + productId + '-large.jpg',  // 2MB
    '/images/product-' + productId + '-detail1.jpg', // 1.5MB
    '/images/product-' + productId + '-detail2.jpg', // 1.8MB
    '/images/product-' + productId + '-review.jpg'   // 1.2MB
  ];
  
  images.forEach(src => {
    const img = new Image();
    img.src = src; // 同期的に全て読み込み開始
  });
  
  // 🚨 問題2: ブロッキングするJavaScript処理
  fetchProductDetails(productId)
    .then(processAllReviews)  // 重い処理
    .then(renderRecommendations); // さらに重い処理
}

// Browser監視で判明したビジネス影響
const businessImpact = {
  pageLoadTime: "3.5秒（業界平均2.1秒）",
  bounceRate: "45%（通常の1.8倍）",
  conversionRate: "1.2%（通常の3.1%から62%減少）",
  revenueImpact: "月間売上15%減少（約150万円の損失）"
};

// Browser監視による最適化（読み込み時間1.2秒）
function loadProductPageOptimized(productId) {
  // ✅ 改善1: 画像の遅延読み込み（Lazy Loading）
  const observer = new IntersectionObserver((entries) => {
    entries.forEach(entry => {
      if (entry.isIntersecting) {
        const img = entry.target;
        img.src = img.dataset.src;
        observer.unobserve(img);
      }
    });
  });
  
  // ✅ 改善2: Critical なコンテンツを優先読み込み
  loadCriticalContent(productId)
    .then(() => {
      // ✅ 改善3: 非同期で付加的コンテンツを読み込み
      Promise.all([
        loadProductImages(productId),
        loadReviewsSummary(productId), // 処理を軽量化
        loadBasicRecommendations(productId) // 重い処理は後で
      ]);
    });
}

// 改善後のビジネス成果
const improvedResults = {
  pageLoadTime: "1.2秒（65%短縮）",
  bounceRate: "26%（42%改善）", 
  conversionRate: "3.4%（183%向上）",
  revenueImpact: "月間売上23%増加（約350万円の増収）"
};

// 実際のビジネス影響データ
const performanceBusinessCorrelation = {
  // ページ速度改善による効果
  loadTimeReduction: {
    "1秒短縮": {
      conversionIncrease: "7%",
      bounceReduction: "11%",
      pageViewsIncrease: "9%"
    },
    "2秒短縮": {
      conversionIncrease: "15%", 
      bounceReduction: "23%",
      revenueIncrease: "12%"
    }
  },
  
  // 業界別の速度要件
  industryRequirements: {
    ecommerce: {
      targetLoadTime: "2秒以下",
      criticalThreshold: "3秒（売上が急減）"
    },
    news: {
      targetLoadTime: "1.5秒以下", 
      criticalThreshold: "2.5秒（離脱率50%超）"
    },
    saas: {
      targetLoadTime: "2.5秒以下",
      criticalThreshold: "4秒（継続利用率低下）"
    }
  }
};

// RUMで自動収集される主要パフォーマンス指標
const rumPerformanceMetrics = {
  // ページロード関連
  navigationTiming: {
    TTFB: "Time to First Byte - 最初のバイト到達時間",
    FCP: "First Contentful Paint - 最初のコンテンツ表示時間", 
    LCP: "Largest Contentful Paint - 最大コンテンツ表示時間",
    TTI: "Time to Interactive - 操作可能になるまでの時間",
    FID: "First Input Delay - 最初の入力への応答時間",
    CLS: "Cumulative Layout Shift - レイアウトのずれ"
  },
  
  // リソース読み込み
  resourceTiming: {
    DNS: "DNS解決時間",
    TCP: "TCP接続時間", 
    SSL: "SSL/TLS接続時間",
    download: "リソースダウンロード時間",
    fileSize: "各リソースのファイルサイズ"
  },
  
  // JavaScript実行
  longTasks: {
    blockingTime: "メインスレッドブロッキング時間",
    taskDuration: "重い処理の実行時間",
    scriptErrors: "JavaScript実行エラー"
  }
};

// ユーザー体験に関する追加メトリクス
const rumUserExperienceMetrics = {
  // セッション情報
  session: {
    duration: "セッション継続時間",
    pageViews: "セッション内ページビュー数",
    bounceRate: "直帰率",
    userFlow: "ページ遷移パターン"
  },
  
  // インタラクション
  userInteraction: {
    clickEvents: "クリック反応時間",
    scrollBehavior: "スクロール深度・速度",
    formInteraction: "フォーム入力パターン",
    searchBehavior: "サイト内検索利用状況"
  },
  
  // コンバージョン
  businessMetrics: {
    conversionFunnel: "コンバージョンファネル分析",
    abandonmentPoints: "離脱ポイントの特定",
    revenueCorrelation: "パフォーマンスと売上の相関"
  }
};

// Node.js + Expressアプリケーションでの例
const newrelic = require('newrelic');
const express = require('express');
const app = express();

// APM設定ファイル（newrelic.js）
module.exports = {
  app_name: ['MyWebApp-Production'],
  license_key: 'YOUR_LICENSE_KEY',
  logging: {
    level: 'info'
  },
  // Browser監視を有効化（重要な設定）
  browser_monitoring: {
    enable: true,
    debug: false,
    // カスタム属性の設定
    attributes: {
      enabled: true,
      include: ['request.headers.userAgent', 'request.url']
    }
  },
  distributed_tracing: {
    enabled: true
  }
};

// HTMLテンプレートでのスクリプト挿入
app.get('/', (req, res) => {
  // New RelicがHTMLヘッダーにBrowserスクリプトを自動挿入
  const browserTimingHeader = newrelic.getBrowserTimingHeader();
  
  res.send(`
    <!DOCTYPE html>
    <html>
    <head>
      <title>MyWebApp</title>
      ${browserTimingHeader} <!-- ここに自動的に挿入される -->
    </head>
    <body>
      <h1>Welcome to MyApp</h1>
      <!-- アプリケーションコンテンツ -->
    </body>
    </html>
  `);
});

// ブラウザコンソールで動作確認
// New Relicオブジェクトの存在確認
if (typeof newrelic !== 'undefined') {
  console.log('✅ New Relic Browser エージェント: 正常動作');
  console.log('App ID:', newrelic.info.applicationID);
  console.log('License Key:', newrelic.info.licenseKey.substring(0, 8) + '...');
} else {
  console.log('❌ New Relic Browser エージェント: 未設置');
}

// パフォーマンス監視の動作確認
window.addEventListener('load', () => {
  setTimeout(() => {
    // Navigation Timing APIによるパフォーマンス計測
    const navigation = performance.getEntriesByType('navigation')[0];
    console.log('🚀 パフォーマンス計測結果:');
    console.log('TTFB:', navigation.responseStart - navigation.requestStart + 'ms');
    console.log('DOM Content Loaded:', navigation.domContentLoadedEventEnd - navigation.navigationStart + 'ms');
    console.log('Load Complete:', navigation.loadEventEnd - navigation.navigationStart + 'ms');
  }, 1000);
});

// New Relic設定のカスタマイズ
window.NREUM.loader_config = {
  // セッション追跡の有効化
  privacy: {
    cookies_enabled: true
  },
  
  // Ajax監視の詳細設定  
  ajax: {
    deny_list: [
      "bam.nr-data.net" // New Relic自身の通信は除外
    ]
  },
  
  // SPA監視の有効化（React、Vue、Angular等）
  spa: {
    enabled: true,
    harvestTimeSeconds: 10 // データ送信間隔
  },
  
  // セッション リプレイの設定（注意：プライバシー配慮が必要）
  session_replay: {
    enabled: false, // デフォルトは無効
    sampling_rate: 0.1, // 有効にする場合は10%程度でサンプリング
    error_sampling_rate: 0.5 // エラー時は50%でキャプチャ
  }
};

// 基本的なカスタムイベントの送信
function trackCustomEvent(eventName, attributes) {
  if (typeof newrelic !== 'undefined') {
    newrelic.addPageAction(eventName, attributes);
  }
}

// ECサイトでの実装例
const ecommerceTracking = {
  // 商品表示イベント
  trackProductView(productId, categoryId, price) {
    trackCustomEvent('ProductView', {
      productId: productId,
      categoryId: categoryId,
      price: price,
      timestamp: Date.now(),
      userAgent: navigator.userAgent,
      screenResolution: `${screen.width}x${screen.height}`
    });
  },
  
  // カート追加イベント  
  trackAddToCart(productId, quantity, totalValue) {
    trackCustomEvent('AddToCart', {
      productId: productId,
      quantity: quantity,
      totalValue: totalValue,
      cartSize: this.getCartSize(),
      sessionDuration: this.getSessionDuration()
    });
  },
  
  // 購入完了イベント
  trackPurchaseComplete(orderId, totalAmount, itemCount) {
    trackCustomEvent('PurchaseComplete', {
      orderId: orderId,
      totalAmount: totalAmount,
      itemCount: itemCount,
      paymentMethod: this.getPaymentMethod(),
      conversionTime: this.getTimeFromFirstVisit()
    });
  }
};

// ユーザー情報とセッション情報の設定
class UserContextManager {
  constructor() {
    this.initializeUserContext();
  }
  
  initializeUserContext() {
    // ユーザー固有の属性を設定
    if (typeof newrelic !== 'undefined') {
      // ユーザー識別情報（個人情報は含めない）
      newrelic.setUserId(this.getHashedUserId());
      
      // ユーザー属性の設定
      newrelic.setCustomAttribute('userSegment', this.getUserSegment());
      newrelic.setCustomAttribute('membershipTier', this.getMembershipTier());
      newrelic.setCustomAttribute('deviceType', this.getDeviceType());
      newrelic.setCustomAttribute('connectionType', this.getConnectionType());
    }
  }
  
  // ユーザーセグメント判定
  getUserSegment() {
    const userData = this.getCurrentUserData();
    if (userData.purchaseHistory > 10) return 'premium';
    if (userData.purchaseHistory > 2) return 'regular';
    return 'new';
  }
  
  // デバイス種別の判定
  getDeviceType() {
    const width = window.screen.width;
    if (width <= 768) return 'mobile';
    if (width <= 1024) return 'tablet';
    return 'desktop';
  }
  
  // 接続種別の推定
  getConnectionType() {
    if ('connection' in navigator) {
      return navigator.connection.effectiveType || 'unknown';
    }
    // フォールバック：パフォーマンスから推定
    const navigation = performance.getEntriesByType('navigation')[0];
    if (navigation.responseStart - navigation.requestStart > 1000) {
      return 'slow';
    }
    return 'unknown';
  }
}

// ユーザー行動の詳細追跡
class UserBehaviorTracker {
  constructor() {
    this.sessionStartTime = Date.now();
    this.scrollDepth = 0;
    this.clickHeatmap = [];
    this.setupEventListeners();
  }
  
  setupEventListeners() {
    // スクロール深度の追跡
    window.addEventListener('scroll', this.trackScrollDepth.bind(this));
    
    // クリックヒートマップの作成
    document.addEventListener('click', this.trackClickLocation.bind(this));
    
    // フォーム操作の追跡
    document.addEventListener('focus', this.trackFormFocus.bind(this), true);
    
    // ページ離脱前の情報送信
    window.addEventListener('beforeunload', this.sendFinalData.bind(this));
  }
  
  trackScrollDepth(event) {
    const scrollPercent = Math.round(
      (window.scrollY / (document.documentElement.scrollHeight - window.innerHeight)) * 100
    );
    
    if (scrollPercent > this.scrollDepth) {
      this.scrollDepth = scrollPercent;
      
      // 25%, 50%, 75%, 100%の節目でイベント送信
      const milestones = [25, 50, 75, 100];
      if (milestones.includes(scrollPercent)) {
        trackCustomEvent('ScrollDepth', {
          depth: scrollPercent,
          timeOnPage: Date.now() - this.sessionStartTime,
          pageUrl: window.location.pathname
        });
      }
    }
  }
  
  trackClickLocation(event) {
    const element = event.target;
    const rect = element.getBoundingClientRect();
    
    trackCustomEvent('ClickHeatmap', {
      elementTag: element.tagName.toLowerCase(),
      elementText: element.textContent?.substring(0, 50) || '',
      xPosition: Math.round(event.clientX),
      yPosition: Math.round(event.clientY),
      elementX: Math.round(rect.left),
      elementY: Math.round(rect.top),
      viewportWidth: window.innerWidth,
      viewportHeight: window.innerHeight
    });
  }
  
  trackFormFocus(event) {
    if (event.target.tagName === 'INPUT' || event.target.tagName === 'TEXTAREA') {
      trackCustomEvent('FormInteraction', {
        fieldType: event.target.type || 'textarea',
        fieldName: event.target.name || 'unnamed',
        formId: event.target.form?.id || 'unnamed',
        timeToFocus: Date.now() - this.sessionStartTime
      });
    }
  }
}

// New Relic による自動エラーキャプチャの強化
window.addEventListener('error', function(event) {
  // New Relic への追加コンテキスト情報付きエラー報告
  if (typeof newrelic !== 'undefined') {
    newrelic.noticeError(event.error, {
      // エラー発生コンテキスト
      errorContext: {
        url: window.location.href,
        userAgent: navigator.userAgent,
        timestamp: new Date().toISOString(),
        userId: getCurrentUserId(), // ハッシュ化されたユーザーID
        sessionId: getSessionId(),
        
        // エラー発生時の状態
        pageLoadTime: performance.now(),
        memoryUsage: performance.memory?.usedJSHeapSize || 'unknown',
        connectionType: navigator.connection?.effectiveType || 'unknown',
        
        // ユーザー行動コンテキスト
        lastUserAction: getLastUserAction(),
        timeFromLastAction: getTimeFromLastAction(),
        scrollPosition: window.scrollY,
        visibilityState: document.visibilityState
      }
    });
  }
});

// Promise の未処理拒否エラー
window.addEventListener('unhandledrejection', function(event) {
  if (typeof newrelic !== 'undefined') {
    newrelic.noticeError(new Error(`Unhandled Promise Rejection: ${event.reason}`), {
      errorType: 'unhandledRejection',
      promiseReason: event.reason.toString(),
      stackTrace: event.reason.stack || 'No stack trace available'
    });
  }
});

// 高度なエラーハンドリングクラス
class ErrorTracker {
  constructor() {
    this.errorQueue = [];
    this.maxQueueSize = 50;
    this.userActions = [];
    this.setupGlobalErrorHandling();
  }
  
  setupGlobalErrorHandling() {
    // グローバルエラーハンドラ
    window.onerror = (message, source, lineno, colno, error) => {
      this.handleError({
        type: 'javascript',
        message: message,
        source: source,
        line: lineno,
        column: colno,
        error: error,
        userActions: [...this.userActions] // 直近のユーザー操作履歴
      });
      return false; // ブラウザのデフォルトエラー処理も実行
    };
    
    // リソース読み込みエラー
    window.addEventListener('error', (event) => {
      if (event.target !== window) {
        this.handleResourceError(event.target);
      }
    }, true);
  }
  
  handleError(errorInfo) {
    // エラーの重要度判定
    const severity = this.categorizeError(errorInfo);
    
    // New Relic への報告
    if (typeof newrelic !== 'undefined') {
      newrelic.noticeError(errorInfo.error || new Error(errorInfo.message), {
        severity: severity,
        category: this.getErrorCategory(errorInfo),
        userImpact: this.assessUserImpact(errorInfo),
        technicalContext: {
          browser: this.getBrowserInfo(),
          performance: this.getPerformanceSnapshot(),
          domState: this.getDOMStateInfo()
        }
      });
    }
    
    // 重要度が高い場合は即座にアラート
    if (severity === 'critical') {
      this.sendImmediateAlert(errorInfo);
    }
  }
  
  handleResourceError(target) {
    const resourceError = {
      type: 'resource',
      resourceType: target.tagName.toLowerCase(),
      src: target.src || target.href,
      currentUrl: window.location.href,
      loadTime: performance.now()
    };
    
    if (typeof newrelic !== 'undefined') {
      newrelic.addPageAction('ResourceLoadError', resourceError);
    }
  }
  
  // エラーの重要度分類
  categorizeError(errorInfo) {
    const message = errorInfo.message.toLowerCase();
    
    // クリティカルエラーの判定
    const criticalPatterns = [
      'cannot read property',
      'undefined is not a function',
      'payment', 'checkout', 'purchase'
    ];
    
    if (criticalPatterns.some(pattern => message.includes(pattern))) {
      return 'critical';
    }
    
    // 警告レベルエラー
    const warningPatterns = [
      'network error', 'loading chunk', '404'
    ];
    
    if (warningPatterns.some(pattern => message.includes(pattern))) {
      return 'warning';
    }
    
    return 'info';
  }
  
  // ユーザーへの影響評価
  assessUserImpact(errorInfo) {
    const criticalPages = ['/checkout', '/payment', '/login'];
    const currentPath = window.location.pathname;
    
    if (criticalPages.some(page => currentPath.includes(page))) {
      return 'high';
    }
    
    // エラー発生頻度での判定
    const recentSimilarErrors = this.errorQueue.filter(
      err => err.message === errorInfo.message && 
      Date.now() - err.timestamp < 60000 // 1分以内
    ).length;
    
    if (recentSimilarErrors > 3) {
      return 'high';
    }
    
    return 'medium';
  }
}

// エラー分析とデバッグ情報の収集
class ErrorAnalyzer {
  
  // パフォーマンス問題の自動検出
  detectPerformanceErrors() {
    const navigation = performance.getEntriesByType('navigation')[0];
    const warnings = [];
    
    // 読み込み時間の警告閾値
    const thresholds = {
      TTFB: 800,        // Time to First Byte
      FCP: 1800,        // First Contentful Paint  
      LCP: 2500,        // Largest Contentful Paint
      totalLoad: 5000   // 総読み込み時間
    };
    
    if (navigation.responseStart - navigation.requestStart > thresholds.TTFB) {
      warnings.push({
        type: 'slow_ttfb',
        value: navigation.responseStart - navigation.requestStart,
        threshold: thresholds.TTFB,
        impact: 'server_response_slow'
      });
    }
    
    if (navigation.loadEventEnd - navigation.navigationStart > thresholds.totalLoad) {
      warnings.push({
        type: 'slow_page_load',
        value: navigation.loadEventEnd - navigation.navigationStart,
        threshold: thresholds.totalLoad,
        impact: 'user_experience_degraded'
      });
    }
    
    // 警告があれば New Relic に送信
    if (warnings.length > 0) {
      warnings.forEach(warning => {
        if (typeof newrelic !== 'undefined') {
          newrelic.addPageAction('PerformanceWarning', warning);
        }
      });
    }
    
    return warnings;
  }
  
  // メモリリークの検出
  detectMemoryLeaks() {
    if (!performance.memory) return null;
    
    const memoryInfo = {
      used: performance.memory.usedJSHeapSize,
      total: performance.memory.totalJSHeapSize,
      limit: performance.memory.jsHeapSizeLimit
    };
    
    // メモリ使用率が80%を超えた場合
    if (memoryInfo.used / memoryInfo.limit > 0.8) {
      if (typeof newrelic !== 'undefined') {
        newrelic.addPageAction('MemoryWarning', {
          usagePercent: Math.round((memoryInfo.used / memoryInfo.limit) * 100),
          usedMB: Math.round(memoryInfo.used / 1024 / 1024),
          limitMB: Math.round(memoryInfo.limit / 1024 / 1024)
        });
      }
    }
    
    return memoryInfo;
  }
  
  // ネットワークエラーの詳細分析
  analyzeNetworkErrors() {
    const resources = performance.getEntriesByType('resource');
    const failedResources = [];
    
    resources.forEach(resource => {
      // 読み込みに失敗した、または異常に遅いリソースを検出
      if (resource.duration > 5000 || resource.transferSize === 0) {
        failedResources.push({
          name: resource.name,
          type: resource.initiatorType,
          duration: resource.duration,
          size: resource.transferSize,
          status: resource.transferSize === 0 ? 'failed' : 'slow'
        });
      }
    });
    
    if (failedResources.length > 0 && typeof newrelic !== 'undefined') {
      newrelic.addPageAction('NetworkErrors', {
        failedCount: failedResources.length,
        resources: failedResources
      });
    }
    
    return failedResources;
  }
}

// Browser監視導入効果の測定フレームワーク
class MonitoringROICalculator {
  
  // 導入前のベースライン設定
  setBaseline(baselineData) {
    this.baseline = {
      // パフォーマンス指標
      performance: {
        averageLoadTime: baselineData.loadTime,
        bounceRate: baselineData.bounceRate,
        conversionRate: baselineData.conversionRate,
        errorFrequency: baselineData.errorFrequency || 'unknown'
      },
      
      // ビジネス指標
      business: {
        monthlyRevenue: baselineData.revenue,
        customerSatisfaction: baselineData.satisfaction,
        supportTickets: baselineData.supportTickets,
        developerProductivity: baselineData.productivity || 'unknown'
      },
      
      // 運用コスト
      operational: {
        incidentResponseTime: baselineData.responseTime || 'unknown',
        debuggingTimePerIssue: baselineData.debugTime || 'unknown',
        infrastructureCosts: baselineData.infraCosts
      }
    };
  }
  
  // 改善成果の計算
  calculateImprovements(currentData, timeframe = 'monthly') {
    const improvements = {
      performance: this.calculatePerformanceROI(currentData),
      business: this.calculateBusinessROI(currentData),
      operational: this.calculateOperationalROI(currentData)
    };
    
    return this.generateROIReport(improvements, timeframe);
  }
  
  calculatePerformanceROI(currentData) {
    const loadTimeImprovement = this.baseline.performance.averageLoadTime - currentData.loadTime;
    const loadTimeImprovementPercent = (loadTimeImprovement / this.baseline.performance.averageLoadTime) * 100;
    
    // Google の研究データに基づく効果計算
    const conversionImprovement = loadTimeImprovementPercent * 0.07; // 1秒短縮で7%向上
    const bounceReduction = loadTimeImprovementPercent * 0.11; // 1秒短縮で11%削減
    
    return {
      loadTimeReduction: {
        value: loadTimeImprovement,
        percent: loadTimeImprovementPercent,
        unit: 'seconds'
      },
      conversionIncrease: {
        value: conversionImprovement,
        percent: conversionImprovement,
        unit: 'percent'
      },
      bounceRateDecrease: {
        value: bounceReduction, 
        percent: bounceReduction,
        unit: 'percent'
      }
    };
  }
  
  calculateBusinessROI(currentData) {
    const conversionImprovement = (currentData.conversionRate - this.baseline.performance.conversionRate) / this.baseline.performance.conversionRate;
    
    // 収益への影響計算
    const revenueIncrease = this.baseline.business.monthlyRevenue * conversionImprovement;
    const annualRevenueIncrease = revenueIncrease * 12;
    
    return {
      monthlyRevenueIncrease: revenueIncrease,
      annualRevenueIncrease: annualRevenueIncrease,
      conversionImprovement: conversionImprovement * 100,
      customerSatisfactionDelta: currentData.satisfaction - this.baseline.business.customerSatisfaction
    };
  }
  
  calculateOperationalROI(currentData) {
    // 開発・運用効率の改善
    const debugTimeReduction = this.baseline.operational.debuggingTimePerIssue - currentData.debuggingTimePerIssue;
    const responseTimeImprovement = this.baseline.operational.incidentResponseTime - currentData.incidentResponseTime;
    
    // 人的コスト削減の計算（時間単価を仮定）
    const developerHourlyRate = 5000; // 開発者時間単価（円）
    const monthlyDebugTimeHours = 40; // 月間デバッグ時間
    
    const monthlyCostSavings = (debugTimeReduction / 60) * monthlyDebugTimeHours * developerHourlyRate;
    
    return {
      debugTimeReduction: {
        value: debugTimeReduction,
        unit: 'minutes per issue'
      },
      responseTimeImprovement: {
        value: responseTimeImprovement,
        unit: 'minutes'
      },
      monthlyCostSavings: monthlyCostSavings,
      annualCostSavings: monthlyCostSavings * 12
    };
  }
  
  generateROIReport(improvements, timeframe) {
    const report = {
      period: timeframe,
      summary: {
        totalROI: this.calculateTotalROI(improvements),
        paybackPeriod: this.calculatePaybackPeriod(improvements),
        netBenefit: this.calculateNetBenefit(improvements)
      },
      details: improvements,
      recommendations: this.generateRecommendations(improvements)
    };
    
    return report;
  }
  
  // 実際の成功事例データ
  getSuccessStoryCaseStudy() {
    return {
      company: "ECサイトA社（仮名）",
      industryType: "ecommerce",
      monthlyVisitors: 500000,
      
      beforeImplementation: {
        averageLoadTime: 4.2,
        bounceRate: 0.42,
        conversionRate: 0.021,
        monthlyRevenue: 15000000,
        debugTimePerIssue: 120, // minutes
        incidentResponseTime: 45 // minutes
      },
      
      afterImplementation: {
        averageLoadTime: 2.1,
        bounceRate: 0.28,
        conversionRate: 0.032,
        monthlyRevenue: 19500000,
        debugTimePerIssue: 35, // minutes
        incidentResponseTime: 12 // minutes
      },
      
      results: {
        performanceImprovement: "読み込み時間50%短縮",
        businessImpact: "月間売上30%増加（+450万円）", 
        operationalEfficiency: "デバッグ時間70%削減",
        roiAchieved: "投資回収期間4.2ヶ月、年間ROI 340%"
      }
    };
  }
}