# インシデント影響度計算スクリプト
import datetime

class IncidentImpactAnalyzer:
    def __init__(self, start_time, end_time, affected_users, normal_tps):
        self.start_time = start_time
        self.end_time = end_time
        self.affected_users = affected_users
        self.normal_tps = normal_tps
        self.duration_minutes = (end_time - start_time).total_seconds() / 60
    
    def calculate_business_impact(self, revenue_per_transaction=10):
        """ビジネス影響の計算"""
        lost_transactions = self.normal_tps * self.duration_minutes * 60
        revenue_loss = lost_transactions * revenue_per_transaction
        
        return {
            'duration_minutes': self.duration_minutes,
            'affected_users': self.affected_users,
            'lost_transactions': lost_transactions,
            'estimated_revenue_loss': revenue_loss
        }
    
    def calculate_sla_impact(self, monthly_target=99.9):
        """SLA影響の計算"""
        monthly_minutes = 30 * 24 * 60  # 30日
        downtime_percentage = (self.duration_minutes / monthly_minutes) * 100
        availability = 100 - downtime_percentage
        sla_violation = monthly_target - availability
        
        return {
            'monthly_availability': availability,
            'sla_target': monthly_target,
            'sla_violation': max(0, sla_violation)
        }

# 使用例
incident_start = datetime.datetime(2023, 1, 15, 14, 30)
incident_end = datetime.datetime(2023, 1, 15, 16, 45)

analyzer = IncidentImpactAnalyzer(
    start_time=incident_start,
    end_time=incident_end,
    affected_users=10000,
    normal_tps=50
)

business_impact = analyzer.calculate_business_impact()
sla_impact = analyzer.calculate_sla_impact()

print(f"影響時間: {business_impact['duration_minutes']} 分")
print(f"影響ユーザー数: {business_impact['affected_users']} 人")
print(f"推定売上損失: ${business_impact['estimated_revenue_loss']:,}")
print(f"SLA違反: {sla_impact['sla_violation']:.3f}%")

# learning_program.py
class TechnicalLearningProgram:
    def __init__(self):
        self.learning_paths = {
            'network_troubleshooting': {
                'beginner': ['tcp_ip_basics', 'packet_analysis', 'dns_fundamentals'],
                'intermediate': ['advanced_routing', 'load_balancer_config', 'vpn_troubleshooting'],
                'advanced': ['network_automation', 'sdn_concepts', 'performance_optimization']
            },
            'system_administration': {
                'beginner': ['linux_basics', 'process_management', 'file_systems'],
                'intermediate': ['performance_tuning', 'security_hardening', 'backup_strategies'],  
                'advanced': ['kernel_optimization', 'cluster_management', 'disaster_recovery']
            }
        }
    
    def generate_learning_plan(self, engineer_skills, incident_analysis):
        """インシデント分析に基づく学習計画生成"""
        skill_gaps = self.identify_skill_gaps(engineer_skills, incident_analysis)
        recommended_courses = []
        
        for gap in skill_gaps:
            if gap['severity'] == 'high':
                recommended_courses.extend(self.learning_paths[gap['category']]['intermediate'])
            elif gap['severity'] == 'critical':
                recommended_courses.extend(self.learning_paths[gap['category']]['advanced'])
                
        return {
            'priority_courses': recommended_courses[:3],
            'timeline': '3 months',
            'assessment_method': 'hands_on_lab'
        }

# monitoring_gap_analysis.py
import json
from datetime import datetime, timedelta

class MonitoringGapAnalyzer:
    def __init__(self, incident_data, current_monitoring):
        self.incidents = incident_data
        self.monitoring = current_monitoring
    
    def analyze_detection_gaps(self):
        """検出ギャップの分析"""
        gaps = []
        
        for incident in self.incidents:
            detection_time = incident['detection_time']
            actual_start = incident['actual_start_time']
            
            # 検出遅延の計算
            detection_delay = (detection_time - actual_start).total_seconds() / 60
            
            if detection_delay > 5:  # 5分以上の遅延
                gaps.append({
                    'incident_id': incident['id'],
                    'delay_minutes': detection_delay,
                    'missed_signals': self.identify_missed_signals(incident),
                    'recommended_metrics': self.recommend_metrics(incident)
                })
        
        return gaps
    
    def identify_missed_signals(self, incident):
        """見逃された兆候の特定"""
        missed_signals = []
        
        # ログパターン分析
        if 'error_log_spike' in incident['precursors']:
            if 'error_rate_monitoring' not in self.monitoring['active_metrics']:
                missed_signals.append('error_rate_monitoring')
        
        # リソース使用量分析
        if 'memory_leak' in incident['root_cause']:
            if 'memory_trend_analysis' not in self.monitoring['active_metrics']:
                missed_signals.append('memory_trend_analysis')
                
        return missed_signals
    
    def recommend_metrics(self, incident):
        """推奨メトリクスの提案"""
        recommendations = []
        
        category = incident['category']
        if category == 'performance':
            recommendations.extend([
                'response_time_percentiles',
                'throughput_trending',
                'resource_saturation_indicators'
            ])
        elif category == 'availability':
            recommendations.extend([
                'health_check_endpoints',
                'dependency_monitoring',
                'circuit_breaker_metrics'
            ])
            
        return recommendations

# dynamic_threshold.py
import numpy as np
from sklearn.ensemble import IsolationForest
from datetime import datetime, timedelta

class DynamicThresholdManager:
    def __init__(self, historical_data):
        self.data = historical_data
        self.models = {}
        
    def train_anomaly_detection(self, metric_name):
        """異常検知モデルの訓練"""
        metric_data = self.data[metric_name]
        
        # 時間的特徴量の生成
        features = []
        for timestamp, value in metric_data:
            hour = timestamp.hour
            day_of_week = timestamp.weekday()
            features.append([value, hour, day_of_week])
        
        # Isolation Forestモデルの訓練
        model = IsolationForest(contamination=0.1, random_state=42)
        model.fit(features)
        
        self.models[metric_name] = model
        
        return model
    
    def calculate_dynamic_threshold(self, metric_name, current_time):
        """動的閾値の計算"""
        if metric_name not in self.models:
            self.train_anomaly_detection(metric_name)
        
        model = self.models[metric_name]
        
        # 現在時刻の特徴量
        hour = current_time.hour
        day_of_week = current_time.weekday()
        
        # 過去データから同じ時間帯の統計を計算
        similar_times = []
        for timestamp, value in self.data[metric_name]:
            if timestamp.hour == hour and timestamp.weekday() == day_of_week:
                similar_times.append(value)
        
        if similar_times:
            mean = np.mean(similar_times)
            std = np.std(similar_times)
            
            # 3シグマルールベースの動的閾値
            upper_threshold = mean + 3 * std
            lower_threshold = mean - 3 * std
            
            return {
                'upper_threshold': upper_threshold,
                'lower_threshold': lower_threshold,
                'baseline': mean,
                'confidence_interval': std
            }
        
        return None
    
    def evaluate_anomaly(self, metric_name, value, timestamp):
        """異常評価"""
        if metric_name not in self.models:
            return False
            
        model = self.models[metric_name]
        hour = timestamp.hour
        day_of_week = timestamp.weekday()
        
        # 異常スコア計算
        anomaly_score = model.decision_function([[value, hour, day_of_week]])[0]
        is_anomaly = model.predict([[value, hour, day_of_week]])[0] == -1
        
        return {
            'is_anomaly': is_anomaly,
            'anomaly_score': anomaly_score,
            'confidence': abs(anomaly_score)
        }

# intelligent_alerting.py
from datetime import datetime, timedelta
import json

class IntelligentAlertManager:
    def __init__(self):
        self.alert_history = []
        self.escalation_rules = {}
        self.suppression_rules = {}
        
    def process_alert(self, alert):
        """アラートの知的処理"""
        # 重複チェック
        if self.is_duplicate_alert(alert):
            return self.update_existing_alert(alert)
        
        # 関連アラートのグルーピング
        related_alerts = self.find_related_alerts(alert)
        if related_alerts:
            return self.create_grouped_alert(alert, related_alerts)
        
        # 重要度の動的調整
        adjusted_severity = self.calculate_dynamic_severity(alert)
        alert['adjusted_severity'] = adjusted_severity
        
        # エスカレーション判定
        escalation_action = self.determine_escalation(alert)
        
        return {
            'action': 'create_new_alert',
            'alert': alert,
            'escalation': escalation_action,
            'suppressed': False
        }
    
    def is_duplicate_alert(self, alert, time_window=300):
        """重複アラート検出（5分以内）"""
        cutoff_time = datetime.now() - timedelta(seconds=time_window)
        
        for existing_alert in self.alert_history:
            if (existing_alert['timestamp'] > cutoff_time and
                existing_alert['source'] == alert['source'] and
                existing_alert['metric'] == alert['metric']):
                return True
        return False
    
    def find_related_alerts(self, alert, correlation_window=60):
        """関連アラートの発見"""
        related = []
        cutoff_time = datetime.now() - timedelta(seconds=correlation_window)
        
        for existing_alert in self.alert_history:
            if existing_alert['timestamp'] > cutoff_time:
                correlation_score = self.calculate_correlation(alert, existing_alert)
                if correlation_score > 0.7:
                    related.append(existing_alert)
        
        return related
    
    def calculate_correlation(self, alert1, alert2):
        """アラート間の相関度計算"""
        correlation_factors = []
        
        # 同一サービス
        if alert1.get('service') == alert2.get('service'):
            correlation_factors.append(0.3)
        
        # 同一ホスト
        if alert1.get('host') == alert2.get('host'):
            correlation_factors.append(0.4)
        
        # 依存関係
        if self.has_dependency(alert1.get('service'), alert2.get('service')):
            correlation_factors.append(0.5)
        
        return sum(correlation_factors)
    
    def calculate_dynamic_severity(self, alert):
        """動的重要度計算"""
        base_severity = alert['severity']
        
        # 時間帯による調整
        current_hour = datetime.now().hour
        if 9 <= current_hour <= 17:  # 営業時間
            time_multiplier = 1.2
        else:
            time_multiplier = 0.8
        
        # 頻度による調整
        recent_count = self.count_recent_alerts(alert['metric'], hours=1)
        if recent_count > 5:
            frequency_multiplier = 1.5
        else:
            frequency_multiplier = 1.0
        
        # ビジネス影響による調整
        business_impact = self.assess_business_impact(alert)
        business_multiplier = business_impact / 10.0
        
        adjusted_severity = base_severity * time_multiplier * frequency_multiplier * business_multiplier
        
        return min(adjusted_severity, 10.0)  # 最大値制限

# knowledge_base.py
class TroubleshootingKnowledgeBase:
    def __init__(self):
        self.knowledge_graph = {
            'symptoms': {},
            'causes': {},
            'solutions': {},
            'relationships': {}
        }
        
    def add_knowledge_entry(self, symptom, cause, solution, metadata):
        """知識エントリの追加"""
        symptom_id = self.generate_id()
        
        self.knowledge_graph['symptoms'][symptom_id] = {
            'description': symptom,
            'keywords': metadata.get('keywords', []),
            'category': metadata.get('category'),
            'severity': metadata.get('severity'),
            'frequency': metadata.get('frequency', 0)
        }
        
        cause_id = self.generate_id()
        self.knowledge_graph['causes'][cause_id] = {
            'description': cause,
            'root_cause_analysis': metadata.get('rca'),
            'likelihood': metadata.get('likelihood', 0.5)
        }
        
        solution_id = self.generate_id()
        self.knowledge_graph['solutions'][solution_id] = {
            'steps': solution['steps'],
            'estimated_time': solution.get('time'),
            'risk_level': solution.get('risk', 'low'),
            'success_rate': solution.get('success_rate', 0.8)
        }
        
        # 関係性の記録
        self.knowledge_graph['relationships'][symptom_id] = {
            'possible_causes': [cause_id],
            'recommended_solutions': [solution_id]
        }
        
    def search_by_symptom(self, symptom_text, similarity_threshold=0.7):
        """症状からの知識検索"""
        matches = []
        
        for symptom_id, symptom_data in self.knowledge_graph['symptoms'].items():
            similarity = self.calculate_similarity(symptom_text, symptom_data['description'])
            if similarity > similarity_threshold:
                related_info = self.get_related_solutions(symptom_id)
                matches.append({
                    'symptom_id': symptom_id,
                    'similarity': similarity,
                    'symptom': symptom_data,
                    'solutions': related_info
                })
        
        return sorted(matches, key=lambda x: x['similarity'], reverse=True)
    
    def recommend_solution(self, symptom_keywords, context):
        """文脈を考慮したソリューション推奨"""
        candidates = self.search_by_symptom(' '.join(symptom_keywords))
        
        # 文脈による重み付け
        for candidate in candidates:
            context_score = self.calculate_context_relevance(candidate, context)
            candidate['final_score'] = candidate['similarity'] * context_score
        
        return sorted(candidates, key=lambda x: x['final_score'], reverse=True)[:3]
    
    def update_solution_effectiveness(self, solution_id, success):
        """ソリューション効果の更新"""
        if solution_id in self.knowledge_graph['solutions']:
            current_rate = self.knowledge_graph['solutions'][solution_id]['success_rate']
            # 移動平均による更新
            new_rate = current_rate * 0.9 + (1.0 if success else 0.0) * 0.1
            self.knowledge_graph['solutions'][solution_id]['success_rate'] = new_rate

# preventive_maintenance.py
import schedule
import time
from datetime import datetime, timedelta
import subprocess

class PreventiveMaintenanceScheduler:
    def __init__(self):
        self.maintenance_tasks = {}
        self.execution_history = []
        
    def register_task(self, name, function, schedule_type, schedule_value):
        """保守タスクの登録"""
        self.maintenance_tasks[name] = {
            'function': function,
            'schedule_type': schedule_type,
            'schedule_value': schedule_value,
            'last_execution': None,
            'status': 'active'
        }
        
        # スケジュールの設定
        if schedule_type == 'daily':
            schedule.every().day.at(schedule_value).do(self._execute_task, name)
        elif schedule_type == 'weekly':
            schedule.every().week.do(self._execute_task, name)
        elif schedule_type == 'monthly':
            schedule.every(30).days.do(self._execute_task, name)
    
    def _execute_task(self, task_name):
        """タスクの実行"""
        if task_name not in self.maintenance_tasks:
            return
            
        task = self.maintenance_tasks[task_name]
        start_time = datetime.now()
        
        try:
            result = task['function']()
            status = 'success'
            error_message = None
        except Exception as e:
            result = None
            status = 'failed'
            error_message = str(e)
        
        end_time = datetime.now()
        
        # 実行履歴の記録
        execution_record = {
            'task_name': task_name,
            'start_time': start_time,
            'end_time': end_time,
            'duration': (end_time - start_time).total_seconds(),
            'status': status,
            'result': result,
            'error_message': error_message
        }
        
        self.execution_history.append(execution_record)
        task['last_execution'] = execution_record
        
        # ログ出力
        print(f"[{start_time}] タスク '{task_name}' 実行完了: {status}")
        if error_message:
            print(f"エラー: {error_message}")
    
    def cleanup_old_logs(self):
        """古いログファイルのクリーンアップ"""
        try:
            # 30日以上古いログファイルを削除
            subprocess.run([
                'find', '/var/log', '-name', '*.log',
                '-mtime', '+30', '-delete'
            ], check=True)
            return "古いログファイルをクリーンアップしました"
        except subprocess.CalledProcessError as e:
            raise Exception(f"ログクリーンアップに失敗: {e}")
    
    def update_system_packages(self):
        """システムパッケージの更新"""
        try:
            # セキュリティ更新のみ適用
            subprocess.run([
                'apt-get', 'update'
            ], check=True, capture_output=True)
            
            result = subprocess.run([
                'apt-get', 'upgrade', '-y', '--security'
            ], check=True, capture_output=True, text=True)
            
            return f"セキュリティ更新完了: {result.stdout}"
        except subprocess.CalledProcessError as e:
            raise Exception(f"パッケージ更新に失敗: {e}")
    
    def backup_configuration(self):
        """設定ファイルのバックアップ"""
        try:
            backup_time = datetime.now().strftime("%Y%m%d_%H%M%S")
            backup_dir = f"/backup/config_{backup_time}"
            
            # 重要な設定ファイルをバックアップ
            config_files = [
                '/etc/apache2/',
                '/etc/mysql/',
                '/etc/nginx/',
                '/etc/ssh/sshd_config'
            ]
            
            subprocess.run(['mkdir', '-p', backup_dir], check=True)
            
            for config_file in config_files:
                subprocess.run([
                    'cp', '-r', config_file, backup_dir
                ], check=True)
            
            return f"設定ファイルをバックアップしました: {backup_dir}"
        except subprocess.CalledProcessError as e:
            raise Exception(f"バックアップに失敗: {e}")

# 使用例
scheduler = PreventiveMaintenanceScheduler()

# 毎日のタスク登録
scheduler.register_task(
    'log_cleanup',
    scheduler.cleanup_old_logs,
    'daily',
    '02:00'
)

# 週次のタスク登録  
scheduler.register_task(
    'security_updates',
    scheduler.update_system_packages,
    'weekly',
    None
)

# 月次のタスク登録
scheduler.register_task(
    'config_backup',
    scheduler.backup_configuration,
    'monthly',
    None
)

# スケジューラー実行
while True:
    schedule.run_pending()
    time.sleep(60)  # 1分間隔でチェック

# chaos_engineering.py
import random
import time
import subprocess
import logging
from datetime import datetime

class ChaosEngineer:
    def __init__(self, test_environment='staging'):
        self.environment = test_environment
        self.active_experiments = []
        self.safety_checks = True
        
        logging.basicConfig(
            filename=f'chaos_test_{datetime.now().strftime("%Y%m%d")}.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
    
    def cpu_stress_test(self, duration=300, cpu_percentage=80):
        """CPU負荷テスト"""
        if not self._safety_check():
            return False
            
        logging.info(f"CPU負荷テスト開始: {cpu_percentage}% for {duration}秒")
        
        try:
            # stressコマンドでCPU負荷を生成
            stress_process = subprocess.Popen([
                'stress', '--cpu', '2', '--timeout', str(duration)
            ])
            
            # システム反応の監視
            self._monitor_system_response('cpu_stress', duration)
            
            stress_process.wait()
            logging.info("CPU負荷テスト完了")
            return True
            
        except Exception as e:
            logging.error(f"CPU負荷テストエラー: {e}")
            return False
    
    def memory_pressure_test(self, memory_mb=1024, duration=300):
        """メモリ圧迫テスト"""
        if not self._safety_check():
            return False
            
        logging.info(f"メモリ圧迫テスト開始: {memory_mb}MB for {duration}秒")
        
        try:
            stress_process = subprocess.Popen([
                'stress', '--vm', '1', '--vm-bytes', f'{memory_mb}M',
                '--timeout', str(duration)
            ])
            
            self._monitor_system_response('memory_pressure', duration)
            
            stress_process.wait()
            logging.info("メモリ圧迫テスト完了")
            return True
            
        except Exception as e:
            logging.error(f"メモリ圧迫テストエラー: {e}")
            return False
    
    def network_partition_test(self, target_host, duration=60):
        """ネットワーク分断テスト"""
        if not self._safety_check():
            return False
            
        logging.info(f"ネットワーク分断テスト開始: {target_host} for {duration}秒")
        
        try:
            # iptablesでトラフィックをブロック
            subprocess.run([
                'iptables', '-A', 'OUTPUT', '-d', target_host, '-j', 'DROP'
            ], check=True)
            
            time.sleep(duration)
            
            # ルールを削除して接続復旧
            subprocess.run([
                'iptables', '-D', 'OUTPUT', '-d', target_host, '-j', 'DROP'
            ], check=True)
            
            logging.info("ネットワーク分断テスト完了")
            return True
            
        except Exception as e:
            logging.error(f"ネットワーク分断テストエラー: {e}")
            # 安全のため強制復旧
            self._emergency_network_restore(target_host)
            return False
    
    def service_failure_test(self, service_name, duration=120):
        """サービス停止テスト"""
        if not self._safety_check():
            return False
            
        logging.info(f"サービス停止テスト開始: {service_name} for {duration}秒")
        
        try:
            # サービス停止
            subprocess.run(['systemctl', 'stop', service_name], check=True)
            
            # 停止期間の待機
            time.sleep(duration)
            
            # サービス再開
            subprocess.run(['systemctl', 'start', service_name], check=True)
            
            # サービス状態確認
            result = subprocess.run(
                ['systemctl', 'is-active', service_name],
                capture_output=True, text=True
            )
            
            if result.stdout.strip() == 'active':
                logging.info(f"サービス停止テスト完了: {service_name} 正常復旧")
                return True
            else:
                logging.error(f"サービス復旧失敗: {service_name}")
                return False
                
        except Exception as e:
            logging.error(f"サービス停止テストエラー: {e}")
            # 強制復旧試行
            subprocess.run(['systemctl', 'start', service_name])
            return False
    
    def _safety_check(self):
        """安全性チェック"""
        if not self.safety_checks:
            return True
            
        # 環境チェック
        if self.environment == 'production':
            logging.warning("本番環境でのカオステストは推奨されません")
            return False
        
        # システム負荷チェック
        load_avg = subprocess.run(
            ['uptime'], capture_output=True, text=True
        ).stdout
        
        # 簡単な負荷確認（詳細な実装は省略）
        if 'load average' in load_avg:
            logging.info(f"現在のシステム負荷: {load_avg.strip()}")
        
        return True
    
    def _monitor_system_response(self, test_type, duration):
        """システム応答監視"""
        monitoring_interval = 10
        monitors = duration // monitoring_interval
        
        for i in range(monitors):
            time.sleep(monitoring_interval)
            
            # 基本メトリクス取得
            cpu_usage = self._get_cpu_usage()
            memory_usage = self._get_memory_usage()
            
            logging.info(
                f"{test_type} 監視 ({i+1}/{monitors}): "
                f"CPU={cpu_usage}%, Memory={memory_usage}%"
            )
    
    def _get_cpu_usage(self):
        """CPU使用率取得"""
        try:
            result = subprocess.run(
                ['top', '-b', '-n1'], capture_output=True, text=True
            )
            for line in result.stdout.split('\n'):
                if 'Cpu(s)' in line:
                    return line.split()[1].replace('%us,', '')
        except:
            return "N/A"
        return "0"
    
    def _get_memory_usage(self):
        """メモリ使用率取得"""
        try:
            result = subprocess.run(
                ['free'], capture_output=True, text=True
            )
            lines = result.stdout.split('\n')
            mem_line = lines[1].split()
            total = int(mem_line[1])
            used = int(mem_line[2])
            return f"{(used/total)*100:.1f}"
        except:
            return "N/A"