ログは戦略的資産！CloudWatch Insightsで運用データから価値を生み出す監視術

// 悪い例：非構造化ログの問題
// この例は、非構造化ログが運用上どんな問題を引き起こすのかを示しています。
// ログが単なる文字列の羅列だと、後から特定の情報を検索したり、分析したりするのが非常に難しくなってしまうんです。
package main

import (
    "log" // Go言語の標準ログ出力パッケージです。
    "fmt" // フォーマットされた文字列を出力するためのパッケージです。
)

func handler(ctx context.Context, request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    // 問題1: ログレベルの不統一
    // `log.Println`や`fmt.Printf`は、ログの重要度（INFO, WARN, ERRORなど）を区別せずにメッセージを出力してしまいます。
    // これだと、後から重要なエラーログだけを抽出する、なんてことができないんですよね。
    log.Println("Starting login process")
    fmt.Printf("User email: %s\n", request.Body)  // 問題：機密情報のログ出力
    // ユーザーのメールアドレスのような機密情報がログにそのまま出力されています。
    // これはセキュリティ上のリスクであり、ログの取り扱いによっては情報漏洩につながる可能性があります。

    // 問題2: 構造化されていない情報
    // ログメッセージが単なる文字列であり、キーと値のペア（例: {"event": "login_process", "user_id": "abc"}）になっていません。
    // このため、特定のフィールド（例: user_id）でログを検索したり、集計したりすることができません。
    log.Printf("Processing login for user at %v", time.Now())

    // 問題3: エラー情報の不十分な記録
    // エラーが発生した際に、エラーメッセージは出力されていますが、そのエラーがどのユーザー、どのリクエスト、
    // どの処理段階で発生したのかといった「コンテキスト情報」が不足しています。
    // コンテキスト情報とは、ログメッセージに付随する追加のデータ（例: リクエストID、ユーザーID、処理中の関数名など）で、
    // 問題の原因特定に役立ちます。
    if err := validateInput(request.Body); err != nil {
        log.Println("Validation failed:", err)  // 問題：コンテキスト情報不足
        return errorResponse, nil
    }

    // 問題4: 成功・失敗の区別困難
    // ログメッセージから、処理が成功したのか失敗したのか、あるいは部分的に成功したのかを判断することが困難です。
    // これでは、システムの健全性を一目で把握することができません。
    log.Println("Login completed")  // 成功？失敗？不明

    return successResponse, nil
}

// このような非構造化ログの問題点:
// - 情報の検索・フィルタリングが困難
// - 時系列分析ができない
// - 関連するログエントリーの紐付けが不可能
// - 定量的な分析ができない
// - 機密情報の意図しない出力

// pkg/logger/structured_logger.go
// 統一された構造化ログシステム

package logger

import (
    "context"
    "encoding/json"
    "os"
    "time"

    "github.com/aws/aws-lambda-go/events"
    "github.com/sirupsen/logrus"
)

type StructuredLogger struct {
    logger      *logrus.Logger
    contextData map[string]interface{}
}

// 統一されたログエントリー構造
type LogEntry struct {
    Timestamp   time.Time              `json:"@timestamp"`
    Level       string                 `json:"@level"`
    Message     string                 `json:"@message"`
    Service     string                 `json:"service"`
    Function    string                 `json:"function"`
    RequestID   string                 `json:"request_id"`
    UserID      string                 `json:"user_id,omitempty"`
    
    // パフォーマンス関連
    Duration    *float64               `json:"duration_ms,omitempty"`
    MemoryUsed  *int64                 `json:"memory_used_mb,omitempty"`
    
    // ビジネス関連
    BusinessEvent string               `json:"business_event,omitempty"`
    BusinessData  map[string]interface{} `json:"business_data,omitempty"`
    
    // 技術関連
    TechnicalEvent string              `json:"technical_event,omitempty"`
    ErrorCategory  string              `json:"error_category,omitempty"`
    ErrorCode      string              `json:"error_code,omitempty"`
    
    // セキュリティ関連
    SecurityEvent  string              `json:"security_event,omitempty"`
    SourceIP      string              `json:"source_ip,omitempty"`
    UserAgent     string              `json:"user_agent,omitempty"`
    
    // カスタムフィールド（検索可能）
    Custom        map[string]interface{} `json:"custom,omitempty"`
}

func New() *StructuredLogger {
    logger := logrus.New()
    logger.SetFormatter(&logrus.JSONFormatter{
        TimestampFormat: time.RFC3339Nano,
    })
    logger.SetOutput(os.Stdout)

    return &StructuredLogger{
        logger:      logger,
        contextData: make(map[string]interface{}),
    }
}

// コンテキスト情報の設定
func (sl *StructuredLogger) WithContext(key string, value interface{}) *StructuredLogger {
    sl.contextData[key] = value
    return sl
}

func (sl *StructuredLogger) WithRequestContext(request events.APIGatewayProxyRequest) *StructuredLogger {
    sl.contextData["request_id"] = request.RequestContext.RequestID
    sl.contextData["source_ip"] = getSourceIP(request)
    sl.contextData["user_agent"] = request.Headers["User-Agent"]
    sl.contextData["http_method"] = request.HTTPMethod
    sl.contextData["path"] = request.Path
    return sl
}

func (sl *StructuredLogger) WithUserContext(userID string) *StructuredLogger {
    sl.contextData["user_id"] = userID
    return sl
}

// ビジネスイベントのログ
func (sl *StructuredLogger) LogBusinessEvent(event string, data map[string]interface{}) {
    entry := sl.createBaseLogEntry("INFO")
    entry.BusinessEvent = event
    entry.BusinessData = data
    
    sl.outputLog(entry)
}

// 技術イベントのログ
func (sl *StructuredLogger) LogTechnicalEvent(event string, data map[string]interface{}) {
    entry := sl.createBaseLogEntry("INFO")
    entry.TechnicalEvent = event
    entry.Custom = data
    
    sl.outputLog(entry)
}

// エラーログ（エラーハンドリングと連携）
func (sl *StructuredLogger) LogError(message string, errorCategory, errorCode string, data map[string]interface{}) {
    entry := sl.createBaseLogEntry("ERROR")
    entry.Message = message
    entry.ErrorCategory = errorCategory
    entry.ErrorCode = errorCode
    entry.Custom = data
    
    sl.outputLog(entry)
}

// セキュリティイベントのログ
func (sl *StructuredLogger) LogSecurityEvent(event string, severity string, data map[string]interface{}) {
    entry := sl.createBaseLogEntry(severity)
    entry.SecurityEvent = event
    entry.Custom = data
    
    // セキュリティログは機密情報をマスキング
    entry.Custom = sl.maskSensitiveData(entry.Custom)
    
    sl.outputLog(entry)
}

// パフォーマンスログ
func (sl *StructuredLogger) LogPerformance(operation string, duration time.Duration, data map[string]interface{}) {
    entry := sl.createBaseLogEntry("INFO")
    entry.Message = fmt.Sprintf("Performance: %s", operation)
    entry.TechnicalEvent = "performance_measurement"
    durationMs := float64(duration.Nanoseconds()) / 1e6
    entry.Duration = &durationMs
    entry.Custom = data
    
    sl.outputLog(entry)
}

// リクエスト/レスポンスログ
func (sl *StructuredLogger) LogRequest(request events.APIGatewayProxyRequest) {
    entry := sl.createBaseLogEntry("INFO")
    entry.TechnicalEvent = "request_received"
    entry.Custom = map[string]interface{}{
        "method":      request.HTTPMethod,
        "path":        request.Path,
        "query_params": request.QueryStringParameters,
        "headers_count": len(request.Headers),
        "body_size":   len(request.Body),
    }
    
    sl.outputLog(entry)
}

func (sl *StructuredLogger) LogResponse(response events.APIGatewayProxyResponse, duration time.Duration) {
    entry := sl.createBaseLogEntry("INFO")
    entry.TechnicalEvent = "response_sent"
    durationMs := float64(duration.Nanoseconds()) / 1e6
    entry.Duration = &durationMs
    entry.Custom = map[string]interface{}{
        "status_code":  response.StatusCode,
        "body_size":    len(response.Body),
        "headers_count": len(response.Headers),
    }
    
    sl.outputLog(entry)
}

func (sl *StructuredLogger) createBaseLogEntry(level string) *LogEntry {
    return &LogEntry{
        Timestamp: time.Now().UTC(),
        Level:     level,
        Service:   "poc-cognite",
        Function:  os.Getenv("AWS_LAMBDA_FUNCTION_NAME"),
        RequestID: sl.getContextValue("request_id"),
        UserID:    sl.getContextValue("user_id"),
        SourceIP:  sl.getContextValue("source_ip"),
        UserAgent: sl.getContextValue("user_agent"),
        Custom:    make(map[string]interface{}),
    }
}

func (sl *StructuredLogger) outputLog(entry *LogEntry) {
    // JSON形式で出力（CloudWatch Logsが自動でパース）
    jsonData, _ := json.Marshal(entry)
    fmt.Println(string(jsonData))
}

// pkg/logger/security_masking.go
// 構造化ログでのセキュリティマスキング

func (sl *StructuredLogger) maskSensitiveData(data map[string]interface{}) map[string]interface{} {
    masked := make(map[string]interface{})
    
    for key, value := range data {
        switch strings.ToLower(key) {
        case "password", "secret", "token", "api_key":
            masked[key] = "***[MASKED]***"
        case "email":
            if strVal, ok := value.(string); ok {
                masked[key] = maskEmail(strVal)
            }
        case "credit_card", "card_number":
            masked[key] = "****-****-****-[MASKED]"
        default:
            // ネストしたマップの再帰処理
            if mapVal, ok := value.(map[string]interface{}); ok {
                masked[key] = sl.maskSensitiveData(mapVal)
            } else {
                // パターンベースのマスキング
                if strVal, ok := value.(string); ok {
                    masked[key] = sl.maskByPattern(strVal)
                } else {
                    masked[key] = value
                }
            }
        }
    }
    
    return masked
}

func (sl *StructuredLogger) maskByPattern(value string) string {
    // JWT トークンのパターン
    jwtPattern := regexp.MustCompile(`eyJ[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.[A-Za-z0-9-_.+/=]*`)
    if jwtPattern.MatchString(value) {
        if len(value) > 20 {
            return value[:10] + "...[MASKED]"
        }
    }
    
    // クレジットカード番号のパターン
    ccPattern := regexp.MustCompile(`\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b`)
    if ccPattern.MatchString(value) {
        return ccPattern.ReplaceAllString(value, "****-****-****-[MASKED]")
    }
    
    return value
}

func maskEmail(email string) string {
    parts := strings.Split(email, "@")
    if len(parts) != 2 {
        return email
    }
    
    username := parts[0]
    domain := parts[1]
    
    if len(username) <= 1 {
        return email
    }
    
    return username[:1] + "***@" + domain
}

-- 1. 基本的なエラー分析クエリ
-- エラー種別・頻度分析
fields @timestamp, error_category, error_code, function, user_id
| filter @level = "ERROR"
| stats count() by error_category, error_code
| sort count desc
| limit 20

-- 時系列エラー分析（1時間区切り）
fields @timestamp, error_category
| filter @level = "ERROR"
| bin(@timestamp, 1h) as time_window
| stats count() by time_window, error_category
| sort time_window desc

-- 特定ユーザーのエラー履歴
fields @timestamp, error_category, error_code, function, custom
| filter @level = "ERROR" and user_id = "user-12345"
| sort @timestamp desc
| limit 50

-- 2. パフォーマンス分析クエリ
-- 応答時間統計
fields @timestamp, duration_ms, function, technical_event
| filter technical_event = "response_sent"
| stats avg(duration_ms) as avg_duration, 
        max(duration_ms) as max_duration,
        count() as request_count by function
| sort avg_duration desc

-- スロークエリ検出（2秒以上）
fields @timestamp, duration_ms, function, custom
| filter duration_ms > 2000
| sort duration_ms desc
| limit 50

-- P95/P99 パフォーマンス分析
fields @timestamp, duration_ms, function
| filter technical_event = "response_sent"
| filter function like /login|register|get-user/
| stats percentile(duration_ms, 95) as p95, 
        percentile(duration_ms, 99) as p99,
        avg(duration_ms) as avg by function
| sort p99 desc

-- 3. ビジネス分析クエリ
-- ユーザー行動分析
fields @timestamp, business_event, business_data, user_id
| filter business_event like /login|register|logout/
| stats count() as event_count by business_event
| sort event_count desc

-- コンバージョンファネル分析
fields @timestamp, business_event, user_id
| filter business_event in ["registration_started", "registration_completed", "login_success"]
| stats count() as count by business_event
| sort @timestamp desc

-- ユーザー継続率分析（日別）
fields @timestamp, business_event, user_id
| filter business_event = "login_success"
| bin(@timestamp, 1d) as date
| stats count_distinct(user_id) as active_users by date
| sort date desc

-- 4. セキュリティ分析クエリ
-- 不審なログイン活動検知
fields @timestamp, source_ip, user_id, security_event, custom
| filter security_event like /login_failure|brute_force/
| stats count() as failure_count by source_ip
| sort failure_count desc
| limit 20

-- 異常なアクセスパターン
fields @timestamp, source_ip, user_agent, technical_event
| filter technical_event = "request_received"
| stats count() as request_count by source_ip, user_agent
| sort request_count desc
| limit 50

-- セキュリティイベント時系列
fields @timestamp, security_event, source_ip, custom
| filter security_event like /.*/
| bin(@timestamp, 10m) as time_window
| stats count() by time_window, security_event
| sort time_window desc

-- 5. 運用分析クエリ
-- Lambda 関数別リクエスト量
fields @timestamp, function, technical_event
| filter technical_event = "request_received"
| bin(@timestamp, 1h) as hour
| stats count() as requests by hour, function
| sort hour desc

-- メモリ使用量分析
fields @timestamp, memory_used_mb, function, duration_ms
| filter memory_used_mb > 0
| stats avg(memory_used_mb) as avg_memory,
        max(memory_used_mb) as max_memory,
        avg(duration_ms) as avg_duration by function
| sort avg_memory desc

-- 外部サービス依存性分析
fields @timestamp, technical_event, custom, duration_ms
| filter technical_event = "external_service_call"
| stats avg(duration_ms) as avg_latency,
        count() as call_count by custom.service_name
| sort avg_latency desc

-- 複合分析クエリ集

-- 1. ユーザージャーニー分析
-- 単一ユーザーの完全なセッション追跡
fields @timestamp, business_event, technical_event, function, custom
| filter user_id = "target-user-id"
| sort @timestamp asc
| limit 200

-- 登録→ログイン完了率分析
fields @timestamp, business_event, user_id
| filter business_event in ["registration_completed", "login_success"]
| stats min(@timestamp) as first_event, 
        max(@timestamp) as last_event,
        count_distinct(business_event) as unique_events by user_id
| filter unique_events = 2
| eval time_to_login = (last_event - first_event) / 60000
| stats avg(time_to_login) as avg_minutes_to_login,
        count() as completed_users

-- 2. パフォーマンス相関分析
-- メモリ使用量と応答時間の相関
fields @timestamp, memory_used_mb, duration_ms, function
| filter memory_used_mb > 0 and duration_ms > 0
| bin(memory_used_mb, 50) as memory_range
| stats avg(duration_ms) as avg_response_time by memory_range, function
| sort memory_range asc

-- 時間帯別パフォーマンス
fields @timestamp, duration_ms, function
| filter technical_event = "response_sent"
| bin(@timestamp, 1h) as hour
| eval hour_of_day = strftime(hour, "%H")
| stats avg(duration_ms) as avg_response, 
        count() as requests by hour_of_day, function
| sort hour_of_day asc

-- 3. 異常検知クエリ
-- 応答時間異常値検出（統計的外れ値）
fields @timestamp, duration_ms, function
| filter duration_ms > 0
| stats avg(duration_ms) as avg_duration,
        stddev(duration_ms) as std_duration by function
| eval threshold = avg_duration + (3 * std_duration)
| fields function, threshold

-- エラー率急増検知
fields @timestamp, @level, function
| bin(@timestamp, 10m) as time_window
| stats count() as total_logs,
        sum(case @level = "ERROR" then 1 else 0 end) as error_count by time_window, function
| eval error_rate = (error_count * 100.0) / total_logs
| filter error_rate > 5
| sort time_window desc

-- 4. ビジネス KPI 分析
-- DAU（Daily Active Users）計算
fields @timestamp, business_event, user_id
| filter business_event = "login_success"
| bin(@timestamp, 1d) as date
| stats count_distinct(user_id) as dau by date
| sort date desc

-- 機能使用率分析
fields @timestamp, business_event, business_data, user_id
| filter business_event like /.*/
| stats count() as usage_count, 
        count_distinct(user_id) as unique_users by business_event
| eval usage_per_user = usage_count / unique_users
| sort usage_count desc

-- コンバージョンファネル詳細分析
fields @timestamp, business_event, user_id, custom
| filter business_event in ["page_view", "registration_started", "registration_completed", "login_success"]
| stats count() as step_count,
        count_distinct(user_id) as unique_users by business_event
| eval conversion_rate = (unique_users * 100.0) / (select count_distinct(user_id) from fields where business_event = "page_view")

// tools/cloudwatch-insights-analyzer.go
// 自動分析レポート生成

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "time"

    "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs"
)

type InsightsAnalyzer struct {
    logsClient    *cloudwatchlogs.Client
    logGroupNames []string
}

type AnalysisReport struct {
    Period          string                    `json:"period"`
    ErrorSummary    ErrorAnalysis             `json:"error_summary"`
    PerformanceData PerformanceAnalysis       `json:"performance_data"`
    BusinessMetrics BusinessAnalysis          `json:"business_metrics"`
    SecurityEvents  SecurityAnalysis          `json:"security_events"`
    Recommendations []string                  `json:"recommendations"`
}

func (ia *InsightsAnalyzer) GenerateComprehensiveReport(ctx context.Context, hours int) (*AnalysisReport, error) {
    endTime := time.Now()
    startTime := endTime.Add(-time.Duration(hours) * time.Hour)

    report := &AnalysisReport{
        Period: fmt.Sprintf("Last %d hours", hours),
    }

    // 並行してデータ取得
    var wg sync.WaitGroup
    var mu sync.Mutex

    // エラー分析
    wg.Add(1)
    go func() {
        defer wg.Done()
        errorData, err := ia.analyzeErrors(ctx, startTime, endTime)
        if err == nil {
            mu.Lock()
            report.ErrorSummary = *errorData
            mu.Unlock()
        }
    }()

    // パフォーマンス分析
    wg.Add(1)
    go func() {
        defer wg.Done()
        perfData, err := ia.analyzePerformance(ctx, startTime, endTime)
        if err == nil {
            mu.Lock()
            report.PerformanceData = *perfData
            mu.Unlock()
        }
    }()

    // ビジネスメトリクス分析
    wg.Add(1)
    go func() {
        defer wg.Done()
        bizData, err := ia.analyzeBusinessMetrics(ctx, startTime, endTime)
        if err == nil {
            mu.Lock()
            report.BusinessMetrics = *bizData
            mu.Unlock()
        }
    }()

    // セキュリティ分析
    wg.Add(1)
    go func() {
        defer wg.Done()
        secData, err := ia.analyzeSecurityEvents(ctx, startTime, endTime)
        if err == nil {
            mu.Lock()
            report.SecurityEvents = *secData
            mu.Unlock()
        }
    }()

    wg.Wait()

    // 推奨事項の生成
    report.Recommendations = ia.generateRecommendations(report)

    return report, nil
}

func (ia *InsightsAnalyzer) analyzeErrors(ctx context.Context, start, end time.Time) (*ErrorAnalysis, error) {
    query := `
    fields @timestamp, error_category, error_code, function, user_id
    | filter @level = "ERROR"
    | stats count() as error_count by error_category, error_code, function
    | sort error_count desc
    | limit 50
    `

    results, err := ia.executeQuery(ctx, query, start, end)
    if err != nil {
        return nil, err
    }

    analysis := &ErrorAnalysis{
        TotalErrors:    0,
        ErrorsByType:   make(map[string]int),
        ErrorsByFunction: make(map[string]int),
        TopErrors:      []ErrorDetail{},
    }

    for _, result := range results {
        category := result["error_category"].(string)
        code := result["error_code"].(string)
        function := result["function"].(string)
        count := int(result["error_count"].(float64))

        analysis.TotalErrors += count
        analysis.ErrorsByType[category] += count
        analysis.ErrorsByFunction[function] += count

        analysis.TopErrors = append(analysis.TopErrors, ErrorDetail{
            Category: category,
            Code:     code,
            Function: function,
            Count:    count,
        })
    }

    return analysis, nil
}

func (ia *InsightsAnalyzer) analyzePerformance(ctx context.Context, start, end time.Time) (*PerformanceAnalysis, error) {
    query := `
    fields @timestamp, duration_ms, function
    | filter technical_event = "response_sent"
    | stats avg(duration_ms) as avg_duration,
            max(duration_ms) as max_duration,
            percentile(duration_ms, 95) as p95_duration,
            count() as request_count by function
    | sort avg_duration desc
    `

    results, err := ia.executeQuery(ctx, query, start, end)
    if err != nil {
        return nil, err
    }

    analysis := &PerformanceAnalysis{
        FunctionPerformance: []FunctionPerformance{},
        OverallStats:        OverallPerformanceStats{},
    }

    var totalRequests int
    var totalDuration float64

    for _, result := range results {
        function := result["function"].(string)
        avgDuration := result["avg_duration"].(float64)
        maxDuration := result["max_duration"].(float64)
        p95Duration := result["p95_duration"].(float64)
        requestCount := int(result["request_count"].(float64))

        analysis.FunctionPerformance = append(analysis.FunctionPerformance, FunctionPerformance{
            FunctionName:  function,
            AvgDuration:   avgDuration,
            MaxDuration:   maxDuration,
            P95Duration:   p95Duration,
            RequestCount:  requestCount,
        })

        totalRequests += requestCount
        totalDuration += avgDuration * float64(requestCount)
    }

    if totalRequests > 0 {
        analysis.OverallStats.OverallAvgDuration = totalDuration / float64(totalRequests)
        analysis.OverallStats.TotalRequests = totalRequests
    }

    return analysis, nil
}

func (ia *InsightsAnalyzer) generateRecommendations(report *AnalysisReport) []string {
    var recommendations []string

    // エラー率に基づく推奨事項
    if report.ErrorSummary.TotalErrors > 100 {
        recommendations = append(recommendations, 
            fmt.Sprintf("高エラー率検出: %d件のエラーが発生しています。主要エラー原因の調査を推奨します。", 
                report.ErrorSummary.TotalErrors))
    }

    // パフォーマンスに基づく推奨事項
    for _, perf := range report.PerformanceData.FunctionPerformance {
        if perf.AvgDuration > 2000 {
            recommendations = append(recommendations, 
                fmt.Sprintf("パフォーマンス改善推奨: %s関数の平均応答時間が%.0fmsです。最適化を検討してください。", 
                    perf.FunctionName, perf.AvgDuration))
        }
    }

    // セキュリティに基づく推奨事項
    if len(report.SecurityEvents.SuspiciousIPs) > 5 {
        recommendations = append(recommendations, 
            fmt.Sprintf("セキュリティ警告: %d個の疑わしいIPアドレスが検出されました。セキュリティ強化を検討してください。", 
                len(report.SecurityEvents.SuspiciousIPs)))
    }

    if len(recommendations) == 0 {
        recommendations = append(recommendations, "現在、システムは正常に動作しています。")
    }

    return recommendations
}

// Slack通知用のレポート送信
func (ia *InsightsAnalyzer) SendReportToSlack(report *AnalysisReport) error {
    message := fmt.Sprintf(`
📊 *運用レポート* (%s)

🚨 *エラーサマリー:*
• 総エラー数: %d件
• 主要エラー: %s

⚡ *パフォーマンス:*
• 平均応答時間: %.0fms
• 総リクエスト数: %d件

🔒 *セキュリティ:*
• 疑わしいIP: %d個
• セキュリティイベント: %d件

💡 *推奨事項:*
%s

詳細ダッシュボード: https://console.aws.amazon.com/cloudwatch/home?region=ap-northeast-1#dashboards:name=poc-cognite-insights
    `,
        report.Period,
        report.ErrorSummary.TotalErrors,
        ia.formatTopErrors(report.ErrorSummary.TopErrors),
        report.PerformanceData.OverallStats.OverallAvgDuration,
        report.PerformanceData.OverallStats.TotalRequests,
        len(report.SecurityEvents.SuspiciousIPs),
        report.SecurityEvents.TotalEvents,
        strings.Join(report.Recommendations, "\n• "),
    )

    return ia.sendSlackMessage(message)
}

運用効率が劇的に向上！

問題発見時間:
  最適化前: 平均2.5時間
  最適化後: 平均8分
  改善率: 95%短縮

原因特定時間:
  最適化前: 平均4時間
  最適化後: 平均25分
  改善率: 90%短縮

定期分析工数:
  最適化前: 週20時間（手動集計・分析）
  最適化後: 週2時間（自動レポート確認）
  改善率: 90%削減

データドリブン意思決定:
  定量的分析可能項目: 5個 → 47個（940%向上）
  自動アラート精度: 65% → 92%（42%向上）
  予防的問題対応率: 20% → 78%（290%向上）

構造化ログ分析で見えてきた、価値ある発見:

パフォーマンス最適化:
  発見1: 
    - 平日12-13時のDynamoDB読み取り遅延（平均+180ms）
    - 原因: ランチタイム集中アクセス
    - 対策: プロビジョン済み容量の時間別調整

  発見2:
    - register関数のメモリ使用量変動（128MB-384MB）
    - 原因: プロフィール画像処理の有無
    - 対策: 処理種別による動的メモリ割り当て

ユーザー行動分析:
  発見3:
    - モバイル・デスクトップでの使用パターン差
    - モバイル: 短時間・高頻度アクセス
    - デスクトップ: 長時間セッション・詳細操作
    - 活用: UI/UX最適化の方向性決定

  発見4:
    - 登録→初回ログイン時間：平均2.3時間
    - 24時間以内ログイン率: 73%
    - 活用: オンボーディングメール最適化

セキュリティ強化:
  発見5:
    - 特定地域からの攻撃パターン（夜間集中）
    - 対策: 地域・時間ベースの動的レート制限

  発見6:
    - ユーザーエージェント偽装の攻撃検知
    - パターン: 同一IPから複数異なるUA
    - 対策: フィンガープリンティング強化

運用最適化:
  発見7:
    - Lambda関数別コールドスタート頻度
    # コールドスタート: Lambda関数が長時間呼び出されなかった後、初めて呼び出される際に発生する初期化時間のことです。
    # これにより、応答時間が長くなることがあります。
    - 高頻度関数: login（10%）、低頻度関数: admin（60%）
    - 対策: Provisioned Concurrencyの戦略的適用
    # Provisioned Concurrency: Lambda関数の実行環境を事前に初期化しておくことで、コールドスタートを排除し、
    # 応答時間を予測可能にする機能です。

  発見8:
    - エラー発生の時系列パターン
    - 週末夜間：認証エラー増加（レジャー利用増）
    - 平日朝：外部API タイムアウト（トラフィック集中）
    - 対策: 時間帯別監視しきい値設定

CloudWatch Insights による自動化成果:

予防保守の実現:
  - 異常値の早期検出: 平均15分で察知
  - 自動スケーリングトリガー: パフォーマンス劣化前に実行
  - 予防的メンテナンス: 問題発生前の対策実施率78%

品質メトリクスの可視化:
  - SLA達成度リアルタイム監視
  # SLA (Service Level Agreement): サービス品質保証。サービス提供者と利用者間で合意されたサービスレベルの指標です。
  # 例えば、APIの応答時間は99.9%の確率で1秒以内といった目標が設定されます。
  - ユーザー満足度関連指標の追跡
  - ビジネスKPIとの相関分析

継続的改善サイクル:
  週次自動レポート:
    - パフォーマンストレンド
    - エラー・セキュリティサマリー
    - 改善推奨事項の自動生成

  月次深掘り分析:
    - 長期トレンド分析
    - 季節性・周期性の発見
    - 投資対効果の定量化

コスト最適化への貢献:
  - 使用量ベースの正確なキャパシティ計画
  - 無駄なリソース特定・削除
  - パフォーマンスとコストの最適バランス発見

構造化ログ・Insights導入の投資対効果:

初期投資:
  設計・実装工数: 48時間
  既存システム移行: 32時間
  CloudWatch Insights 学習コスト: 24時間
  総工数: 104時間（$5,200相当）

運用コスト:
  CloudWatch Logs 保存: +$15/月
  Insights クエリ実行: +$25/月
  自動レポート Lambda: +$3/月
  総追加コスト: +$43/月

削減効果（月間）:
  運用・監視工数削減: 70時間 × $50/時間 = $3,500
  障害対応時間削減: 15時間 × $50/時間 = $750
  予防保守による損失回避: $1,200
  意思決定効率化: $800
  
  月間効果: $6,250
  年間効果: $75,000

ROI計算:
  初期投資: $5,200
  年間運用コスト: $516
  年間効果: $75,000
  ROI: 1,348%（非常に高い投資対効果）
  # ROI (Return on Investment) は「投資収益率」を意味し、投資した費用に対してどれだけの利益が得られたかを示す指標です。
  # ここでは、構造化ログとCloudWatch Insights導入にかけたコストと、それによって得られた削減効果を比較しています。

無形価値:
  # 無形価値とは、数値では直接測れないものの、プロジェクトや組織にとって非常に重要な価値のことです。
  - データドリブンな意思決定文化の定着
  - チーム全体の技術スキル向上
  - システムに対する深い理解と自信
  - ユーザー満足度向上による長期価値創出