4.2 サーバー・VM・クラウド監視 - 統合インフラ環境の包括的監視 ​

# Windows エンタープライズ監視スクリプト
# C:\Scripts\Enterprise-Windows-Monitor.ps1

param(
    [Parameter(Mandatory=$true)]
    [string]$NewRelicInsertKey,
    
    [Parameter(Mandatory=$true)]  
    [string]$NewRelicAccountId,
    
    [string]$Environment = "production"
)

# 設定
$InsightsAPI = "https://insights-collector.newrelic.com/v1/accounts/$NewRelicAccountId/events"
$Hostname = $env:COMPUTERNAME

# システムメトリクス収集
function Collect-SystemMetrics {
    Write-Host "=== Collecting Windows System Metrics ===" -ForegroundColor Green
    
    # CPU使用率
    $CPUUsage = Get-WmiObject Win32_Processor | Measure-Object -Property LoadPercentage -Average | Select-Object -ExpandProperty Average
    
    # メモリ情報
    $TotalMemory = (Get-WmiObject Win32_ComputerSystem).TotalPhysicalMemory
    $FreeMemory = (Get-WmiObject Win32_OperatingSystem).FreePhysicalMemory * 1024
    $UsedMemory = $TotalMemory - $FreeMemory
    $MemoryUsagePercent = [math]::Round(($UsedMemory / $TotalMemory) * 100, 2)
    
    # ディスク情報
    $DiskInfo = Get-WmiObject Win32_LogicalDisk | Where-Object {$_.DriveType -eq 3} | ForEach-Object {
        [PSCustomObject]@{
            DriveLetter = $_.DeviceID
            TotalSize = $_.Size
            FreeSpace = $_.FreeSpace
            UsedSpace = $_.Size - $_.FreeSpace
            UsagePercent = [math]::Round((($_.Size - $_.FreeSpace) / $_.Size) * 100, 2)
        }
    }
    
    # プロセス統計
    $TotalProcesses = (Get-Process).Count
    $RunningServices = (Get-Service | Where-Object {$_.Status -eq 'Running'}).Count
    $StoppedServices = (Get-Service | Where-Object {$_.Status -eq 'Stopped'}).Count
    
    # ネットワーク統計
    $NetworkAdapters = Get-WmiObject Win32_NetworkAdapter | Where-Object {$_.NetEnabled -eq $true}
    $ActiveConnections = (Get-NetTCPConnection | Where-Object {$_.State -eq 'Established'}).Count
    
    # メトリクスデータ構築
    $MetricsData = @{
        eventType = "WindowsSystemMetrics"
        timestamp = [int64](([datetime]::UtcNow) - (Get-Date "1/1/1970")).TotalSeconds
        hostname = $Hostname
        environment = $Environment
        "cpu.usage_percent" = $CPUUsage
        "memory.total_bytes" = $TotalMemory
        "memory.used_bytes" = $UsedMemory
        "memory.free_bytes" = $FreeMemory
        "memory.usage_percent" = $MemoryUsagePercent
        "processes.total" = $TotalProcesses
        "services.running" = $RunningServices
        "services.stopped" = $StoppedServices
        "network.active_connections" = $ActiveConnections
        "network.adapters_enabled" = $NetworkAdapters.Count
    }
    
    # ディスク情報を追加
    foreach ($Disk in $DiskInfo) {
        $DriveLetter = $Disk.DriveLetter.Replace(":", "")
        $MetricsData["disk.$DriveLetter.total_bytes"] = $Disk.TotalSize
        $MetricsData["disk.$DriveLetter.used_bytes"] = $Disk.UsedSpace
        $MetricsData["disk.$DriveLetter.free_bytes"] = $Disk.FreeSpace
        $MetricsData["disk.$DriveLetter.usage_percent"] = $Disk.UsagePercent
    }
    
    # New Relicに送信
    Send-MetricsToNewRelic -Data $MetricsData
}

# IIS監視
function Collect-IISMetrics {
    Write-Host "=== Collecting IIS Metrics ===" -ForegroundColor Green
    
    if (Get-WindowsFeature -Name IIS-WebServerRole -ErrorAction SilentlyContinue) {
        # IIS統計取得
        $IISSites = Get-IISSite
        $W3WPProcesses = Get-Process -Name w3wp -ErrorAction SilentlyContinue
        
        # アプリケーションプール統計
        $AppPools = Get-IISAppPool
        $RunningAppPools = ($AppPools | Where-Object {$_.State -eq 'Started'}).Count
        $StoppedAppPools = ($AppPools | Where-Object {$_.State -eq 'Stopped'}).Count
        
        $IISData = @{
            eventType = "WindowsIISMetrics"
            timestamp = [int64](([datetime]::UtcNow) - (Get-Date "1/1/1970")).TotalSeconds
            hostname = $Hostname
            environment = $Environment
            "iis.sites_total" = $IISSites.Count
            "iis.worker_processes" = $W3WPProcesses.Count
            "iis.app_pools_running" = $RunningAppPools
            "iis.app_pools_stopped" = $StoppedAppPools
        }
        
        Send-MetricsToNewRelic -Data $IISData
    }
}

# SQL Server監視
function Collect-SQLServerMetrics {
    Write-Host "=== Collecting SQL Server Metrics ===" -ForegroundColor Green
    
    try {
        # SQL Serverサービス確認
        $SQLService = Get-Service -Name "MSSQLSERVER" -ErrorAction SilentlyContinue
        
        if ($SQLService -and $SQLService.Status -eq 'Running') {
            # SQL Server接続試行
            $ConnectionString = "Server=localhost;Database=master;Integrated Security=true;Connection Timeout=10;"
            $Connection = New-Object System.Data.SqlClient.SqlConnection($ConnectionString)
            $Connection.Open()
            
            # 基本統計クエリ
            $Command = $Connection.CreateCommand()
            $Command.CommandText = @"
                SELECT 
                    (SELECT COUNT(*) FROM sys.dm_exec_sessions WHERE is_user_process = 1) as ActiveConnections,
                    (SELECT COUNT(*) FROM sys.databases WHERE state = 0) as OnlineDatabases,
                    (SELECT COUNT(*) FROM sys.dm_exec_requests) as ActiveRequests
"@
            
            $Reader = $Command.ExecuteReader()
            if ($Reader.Read()) {
                $SQLData = @{
                    eventType = "WindowsSQLServerMetrics"
                    timestamp = [int64](([datetime]::UtcNow) - (Get-Date "1/1/1970")).TotalSeconds
                    hostname = $Hostname
                    environment = $Environment
                    "sqlserver.service_status" = $SQLService.Status
                    "sqlserver.active_connections" = $Reader["ActiveConnections"]
                    "sqlserver.online_databases" = $Reader["OnlineDatabases"]
                    "sqlserver.active_requests" = $Reader["ActiveRequests"]
                }
                
                Send-MetricsToNewRelic -Data $SQLData
            }
            
            $Reader.Close()
            $Connection.Close()
        }
    }
    catch {
        Write-Warning "SQL Server metrics collection failed: $($_.Exception.Message)"
    }
}

# Active Directory監視
function Collect-ActiveDirectoryMetrics {
    Write-Host "=== Collecting Active Directory Metrics ===" -ForegroundColor Green
    
    try {
        # Domain Controller確認
        $DCRole = Get-WindowsFeature -Name AD-Domain-Services -ErrorAction SilentlyContinue
        
        if ($DCRole -and $DCRole.InstallState -eq 'Installed') {
            # AD統計取得
            $ADUsers = (Get-ADUser -Filter * -ErrorAction SilentlyContinue).Count
            $ADComputers = (Get-ADComputer -Filter * -ErrorAction SilentlyContinue).Count
            $ADGroups = (Get-ADGroup -Filter * -ErrorAction SilentlyContinue).Count
            
            # FSMO役割確認
            $FSMORoles = Get-ADForest | Select-Object -ExpandProperty SchemaMaster, DomainNamingMaster
            $IsFSMOHolder = ($FSMORoles -contains $env:COMPUTERNAME)
            
            $ADData = @{
                eventType = "WindowsActiveDirectoryMetrics"
                timestamp = [int64](([datetime]::UtcNow) - (Get-Date "1/1/1970")).TotalSeconds
                hostname = $Hostname
                environment = $Environment
                "ad.users_count" = $ADUsers
                "ad.computers_count" = $ADComputers
                "ad.groups_count" = $ADGroups
                "ad.is_fsmo_holder" = $IsFSMOHolder
                "ad.service_running" = (Get-Service -Name "NTDS" -ErrorAction SilentlyContinue).Status -eq 'Running'
            }
            
            Send-MetricsToNewRelic -Data $ADData
        }
    }
    catch {
        Write-Warning "Active Directory metrics collection failed: $($_.Exception.Message)"
    }
}

# New Relicへのメトリクス送信
function Send-MetricsToNewRelic {
    param(
        [hashtable]$Data
    )
    
    try {
        $JsonData = $Data | ConvertTo-Json -Compress
        $Body = "[$JsonData]"
        
        $Headers = @{
            'Content-Type' = 'application/json'
            'X-Insert-Key' = $NewRelicInsertKey
        }
        
        Invoke-RestMethod -Uri $InsightsAPI -Method POST -Headers $Headers -Body $Body
        Write-Host "Metrics sent successfully for $($Data.eventType)" -ForegroundColor Green
    }
    catch {
        Write-Error "Failed to send metrics to New Relic: $($_.Exception.Message)"
    }
}

# メイン実行
function Main {
    Write-Host "Starting Windows Enterprise Monitoring for $Hostname" -ForegroundColor Cyan
    Write-Host "Timestamp: $(Get-Date)" -ForegroundColor Cyan
    
    # 各種メトリクス収集実行
    Collect-SystemMetrics
    Collect-IISMetrics
    Collect-SQLServerMetrics
    Collect-ActiveDirectoryMetrics
    
    Write-Host "Windows monitoring data collection completed" -ForegroundColor Cyan
}

# 引数による実行制御
switch ($args[0]) {
    "system" { Collect-SystemMetrics }
    "iis" { Collect-IISMetrics }
    "sqlserver" { Collect-SQLServerMetrics }
    "ad" { Collect-ActiveDirectoryMetrics }
    default { Main }
}

# Hyper-V エンタープライズ監視スクリプト
# C:\Scripts\Enterprise-HyperV-Monitor.ps1

param(
    [Parameter(Mandatory=$true)]
    [string]$NewRelicInsertKey,
    
    [Parameter(Mandatory=$true)]
    [string]$NewRelicAccountId,
    
    [string]$Environment = "production"
)

# 設定
$InsightsAPI = "https://insights-collector.newrelic.com/v1/accounts/$NewRelicAccountId/events"
$Hostname = $env:COMPUTERNAME

# Hyper-V ホスト情報収集
function Collect-HyperVHostMetrics {
    Write-Host "=== Collecting Hyper-V Host Metrics ===" -ForegroundColor Green
    
    try {
        # Hyper-V機能確認
        $HyperVFeature = Get-WindowsFeature -Name Hyper-V -ErrorAction SilentlyContinue
        if (-not ($HyperVFeature -and $HyperVFeature.InstallState -eq 'Installed')) {
            Write-Warning "Hyper-V role not installed"
            return
        }
        
        # ホストリソース情報
        $VMHost = Get-VMHost
        $HostProcessor = Get-WmiObject Win32_Processor | Select-Object -First 1
        $HostMemory = Get-WmiObject Win32_ComputerSystem
        
        # 仮想マシン統計
        $AllVMs = Get-VM
        $RunningVMs = $AllVMs | Where-Object {$_.State -eq 'Running'}
        $StoppedVMs = $AllVMs | Where-Object {$_.State -eq 'Off'}
        $PausedVMs = $AllVMs | Where-Object {$_.State -eq 'Paused'}
        
        # 仮想スイッチ統計
        $VirtualSwitches = Get-VMSwitch
        $ExternalSwitches = $VirtualSwitches | Where-Object {$_.SwitchType -eq 'External'}
        $InternalSwitches = $VirtualSwitches | Where-Object {$_.SwitchType -eq 'Internal'}
        $PrivateSwitches = $VirtualSwitches | Where-Object {$_.SwitchType -eq 'Private'}
        
        # リソースプール統計
        $ProcessorPools = Get-VMResourcePool -ResourcePoolType Processor
        $MemoryPools = Get-VMResourcePool -ResourcePoolType Memory
        
        $HostData = @{
            eventType = "HyperVHostMetrics"
            timestamp = [int64](([datetime]::UtcNow) - (Get-Date "1/1/1970")).TotalSeconds
            hostname = $Hostname
            environment = $Environment
            "host.hyperv_version" = $VMHost.Version
            "host.virtual_hard_disk_path" = $VMHost.VirtualHardDiskPath
            "host.virtual_machine_path" = $VMHost.VirtualMachinePath
            "host.processor_cores" = $HostProcessor.NumberOfCores
            "host.logical_processors" = $HostProcessor.NumberOfLogicalProcessors
            "host.total_memory_gb" = [math]::Round($HostMemory.TotalPhysicalMemory / 1GB, 2)
            "vms.total" = $AllVMs.Count
            "vms.running" = $RunningVMs.Count
            "vms.stopped" = $StoppedVMs.Count
            "vms.paused" = $PausedVMs.Count
            "switches.total" = $VirtualSwitches.Count
            "switches.external" = $ExternalSwitches.Count
            "switches.internal" = $InternalSwitches.Count
            "switches.private" = $PrivateSwitches.Count
            "resource_pools.processor" = $ProcessorPools.Count
            "resource_pools.memory" = $MemoryPools.Count
        }
        
        Send-MetricsToNewRelic -Data $HostData
    }
    catch {
        Write-Error "Failed to collect Hyper-V host metrics: $($_.Exception.Message)"
    }
}

# 仮想マシン詳細情報収集
function Collect-HyperVVMMetrics {
    Write-Host "=== Collecting Hyper-V VM Metrics ===" -ForegroundColor Green
    
    try {
        $VMs = Get-VM
        
        foreach ($VM in $VMs) {
            # 基本VM情報
            $VMData = @{
                eventType = "HyperVVMMetrics"
                timestamp = [int64](([datetime]::UtcNow) - (Get-Date "1/1/1970")).TotalSeconds
                hostname = $Hostname
                environment = $Environment
                "vm.name" = $VM.Name
                "vm.state" = $VM.State
                "vm.status" = $VM.Status
                "vm.generation" = $VM.Generation
                "vm.version" = $VM.Version
                "vm.cpu_count" = $VM.ProcessorCount
                "vm.memory_assigned_mb" = $VM.MemoryAssigned / 1MB
                "vm.memory_startup_mb" = $VM.MemoryStartup / 1MB
                "vm.dynamic_memory_enabled" = $VM.DynamicMemoryEnabled
                "vm.uptime_seconds" = $VM.Uptime.TotalSeconds
            }
            
            # 動的メモリ設定
            if ($VM.DynamicMemoryEnabled) {
                $VMData["vm.memory_minimum_mb"] = $VM.MemoryMinimum / 1MB
                $VMData["vm.memory_maximum_mb"] = $VM.MemoryMaximum / 1MB
            }
            
            # パフォーマンス統計（実行中の場合）
            if ($VM.State -eq 'Running') {
                try {
                    # CPU使用率
                    $VMProcessor = Get-Counter "\Hyper-V Hypervisor Virtual Processor(*)\% Guest Run Time" | 
                                  Where-Object {$_.CounterSamples.InstanceName -like "*$($VM.Name)*"} |
                                  Select-Object -First 1
                    
                    if ($VMProcessor) {
                        $VMData["vm.cpu_usage_percent"] = [math]::Round($VMProcessor.CounterSamples.CookedValue, 2)
                    }
                    
                    # メモリ圧力
                    $MemoryPressure = Get-Counter "\Hyper-V Dynamic Memory VM(*)\Current Pressure" |
                                     Where-Object {$_.CounterSamples.InstanceName -eq $VM.Name} |
                                     Select-Object -First 1
                    
                    if ($MemoryPressure) {
                        $VMData["vm.memory_pressure"] = [math]::Round($MemoryPressure.CounterSamples.CookedValue, 2)
                    }
                }
                catch {
                    Write-Warning "Failed to collect performance data for VM: $($VM.Name)"
                }
            }
            
            # ネットワークアダプター情報
            $NetworkAdapters = Get-VMNetworkAdapter -VM $VM
            $VMData["vm.network_adapters"] = $NetworkAdapters.Count
            
            # ハードディスク情報
            $HardDrives = Get-VMHardDiskDrive -VM $VM
            $VMData["vm.hard_drives"] = $HardDrives.Count
            
            # 統合サービス状態
            $IntegrationServices = Get-VMIntegrationService -VM $VM
            $EnabledServices = ($IntegrationServices | Where-Object {$_.Enabled}).Count
            $VMData["vm.integration_services_enabled"] = $EnabledServices
            $VMData["vm.integration_services_total"] = $IntegrationServices.Count
            
            Send-MetricsToNewRelic -Data $VMData
        }
    }
    catch {
        Write-Error "Failed to collect VM metrics: $($_.Exception.Message)"
    }
}

# 仮想スイッチ詳細監視
function Collect-HyperVSwitchMetrics {
    Write-Host "=== Collecting Hyper-V Switch Metrics ===" -ForegroundColor Green
    
    try {
        $Switches = Get-VMSwitch
        
        foreach ($Switch in $Switches) {
            $SwitchData = @{
                eventType = "HyperVSwitchMetrics"
                timestamp = [int64](([datetime]::UtcNow) - (Get-Date "1/1/1970")).TotalSeconds
                hostname = $Hostname
                environment = $Environment
                "switch.name" = $Switch.Name
                "switch.type" = $Switch.SwitchType
                "switch.allow_management_os" = $Switch.AllowManagementOS
                "switch.embedded_teaming_enabled" = $Switch.EmbeddedTeamingEnabled
                "switch.iov_enabled" = $Switch.IovEnabled
                "switch.packet_direct_enabled" = $Switch.PacketDirectEnabled
            }
            
            # 外部スイッチの場合、物理アダプター情報
            if ($Switch.SwitchType -eq 'External') {
                $NetAdapter = Get-NetAdapter | Where-Object {$_.InterfaceDescription -eq $Switch.NetAdapterInterfaceDescription}
                if ($NetAdapter) {
                    $SwitchData["switch.physical_adapter"] = $NetAdapter.Name
                    $SwitchData["switch.link_speed_gbps"] = $NetAdapter.LinkSpeed / 1000000000
                    $SwitchData["switch.adapter_status"] = $NetAdapter.Status
                }
            }
            
            # 接続されたVM数
            $ConnectedVMs = Get-VMNetworkAdapter | Where-Object {$_.SwitchName -eq $Switch.Name}
            $SwitchData["switch.connected_vms"] = $ConnectedVMs.Count
            
            Send-MetricsToNewRelic -Data $SwitchData
        }
    }
    catch {
        Write-Error "Failed to collect switch metrics: $($_.Exception.Message)"
    }
}

# New Relicへの送信関数
function Send-MetricsToNewRelic {
    param([hashtable]$Data)
    
    try {
        $JsonData = $Data | ConvertTo-Json -Compress
        $Body = "[$JsonData]"
        
        $Headers = @{
            'Content-Type' = 'application/json'
            'X-Insert-Key' = $NewRelicInsertKey
        }
        
        Invoke-RestMethod -Uri $InsightsAPI -Method POST -Headers $Headers -Body $Body
        Write-Host "✅ Metrics sent for $($Data.eventType): $($Data."vm.name" ?? $Data."switch.name" ?? "Host")" -ForegroundColor Green
    }
    catch {
        Write-Error "Failed to send metrics to New Relic: $($_.Exception.Message)"
    }
}

# メイン実行
function Main {
    Write-Host "🚀 Starting Hyper-V Enterprise Monitoring for $Hostname" -ForegroundColor Cyan
    Write-Host "📅 Timestamp: $(Get-Date)" -ForegroundColor Cyan
    
    # 各種メトリクス収集
    Collect-HyperVHostMetrics
    Collect-HyperVVMMetrics
    Collect-HyperVSwitchMetrics
    
    Write-Host "✅ Hyper-V monitoring completed" -ForegroundColor Cyan
}

# 実行
Main