rl544
574 lines
19 KiB
Go
574 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gingfrederik/docx"
|
|
_ "github.com/lib/pq"
|
|
)
|
|
|
|
type Config struct {
|
|
DBHost string `json:"db_host"`
|
|
DBPort int `json:"db_port"`
|
|
DBUser string `json:"db_user"`
|
|
DBPassword string `json:"db_password"`
|
|
DBName string `json:"db_name"`
|
|
}
|
|
|
|
type MetricRecord struct {
|
|
Hostname string
|
|
Timestamp time.Time
|
|
TotalCpu float64
|
|
TotalMem float64
|
|
DpcInterrupt float64
|
|
TopCpuProcesses string
|
|
TopIoProcesses string
|
|
NetworkConnections string
|
|
HungProcesses string
|
|
}
|
|
|
|
type ProcessCPU struct {
|
|
ProcessName string `json:"ProcessName"`
|
|
PID int `json:"PID"`
|
|
CPUPercent float64 `json:"CPU_Percent"`
|
|
KernelCPUPercent float64 `json:"Kernel_CPU_Percent"`
|
|
}
|
|
|
|
type ProcessIO struct {
|
|
ProcessName string `json:"ProcessName"`
|
|
PID int `json:"PID"`
|
|
IODataBytesPersec float64 `json:"IODataBytesPersec"`
|
|
}
|
|
|
|
type NetConn struct {
|
|
ProcessName string `json:"ProcessName"`
|
|
PID int `json:"PID"`
|
|
RemoteAddress string `json:"RemoteAddress"`
|
|
RemotePort int `json:"RemotePort"`
|
|
IOBytesPerSec float64 `json:"IO_BytesPerSec"`
|
|
}
|
|
|
|
type ProcessHung struct {
|
|
ProcessName string `json:"ProcessName"`
|
|
PID int `json:"PID"`
|
|
}
|
|
|
|
type DevToolUsage struct {
|
|
ProcessName string `json:"processName"`
|
|
Count int `json:"count"`
|
|
MaxCPU float64 `json:"maxCpu"`
|
|
MaxIO float64 `json:"maxIo"`
|
|
}
|
|
|
|
type kv struct {
|
|
Key string
|
|
Value int
|
|
}
|
|
func sortMap(m map[string]int) []kv {
|
|
var ss []kv
|
|
for k, v := range m { ss = append(ss, kv{k, v}) }
|
|
sort.Slice(ss, func(i, j int) bool { return ss[i].Value > ss[j].Value })
|
|
return ss
|
|
}
|
|
|
|
func isIgnoredProcess(name string) bool {
|
|
name = strings.ToLower(name)
|
|
if idx := strings.Index(name, "#"); idx != -1 { name = name[:idx] }
|
|
ignoreList := map[string]bool{
|
|
"idle": true, "_total": true, "taskmgr": true,
|
|
"wmiprvse": true, "powershell": true, "pwsh": true, "dwm": true,
|
|
}
|
|
return ignoreList[name]
|
|
}
|
|
|
|
func isDevTool(name string) bool {
|
|
name = strings.ToLower(name)
|
|
if idx := strings.Index(name, "#"); idx != -1 { name = name[:idx] }
|
|
devTools := map[string]bool{
|
|
"code": true, "eclipse": true, "idea64": true, "java": true,
|
|
"node": true, "msbuild": true, "docker": true, "git": true,
|
|
"devenv": true, "python": true, "python3": true, "goland": true,
|
|
}
|
|
return devTools[name]
|
|
}
|
|
|
|
func isSecProc(name string) bool {
|
|
name = strings.ToLower(name)
|
|
if idx := strings.Index(name, "#"); idx != -1 { name = name[:idx] }
|
|
secTools := map[string]bool{
|
|
"v3svc": true, "asdsvc": true, "v3main": true, "v3lite": true,
|
|
"privacyi": true, "piagent": true, "ngm": true, "corebguard": true,
|
|
"gncsensor": true, "gsagent": true, "gsprotect": true, "gsview": true, "gsflow": true,
|
|
}
|
|
return secTools[name]
|
|
}
|
|
|
|
func isSecDriver(name string) bool {
|
|
name = strings.ToLower(name)
|
|
return strings.HasPrefix(name, "v3") || strings.Contains(name, "ahnlab") || strings.Contains(name, "asd") ||
|
|
strings.Contains(name, "privacy") || strings.Contains(name, "piagent") || strings.Contains(name, "somansa") || strings.Contains(name, "ngm") ||
|
|
strings.Contains(name, "gnc") || strings.Contains(name, "gsagent") || strings.Contains(name, "gsprotect") || strings.Contains(name, "gsflow") || strings.Contains(name, "genian")
|
|
}
|
|
|
|
func getProcessTag(name string) string {
|
|
if isDevTool(name) { return " 💻[개발/빌드 도구]" }
|
|
if isSecProc(name) { return " 🛡️[보안 프로그램]" }
|
|
return ""
|
|
}
|
|
|
|
type DetailRecord struct {
|
|
Category string
|
|
Content []string
|
|
}
|
|
|
|
func main() {
|
|
etlPath := flag.String("etl", "", "분석할 .etl 파일 경로")
|
|
flag.Parse()
|
|
|
|
configFile, err := ioutil.ReadFile("config.json")
|
|
if err != nil { log.Fatalf("config.json 읽기 실패: %v", err) }
|
|
var config Config
|
|
json.Unmarshal(configFile, &config)
|
|
|
|
dbUrl := fmt.Sprintf("postgres://%s:%s@%s:%d/%s?sslmode=disable", config.DBUser, config.DBPassword, config.DBHost, config.DBPort, config.DBName)
|
|
db, err := sql.Open("postgres", dbUrl)
|
|
if err != nil { log.Fatalf("DB 연결 실패: %v", err) }
|
|
defer db.Close()
|
|
|
|
timestampStr := time.Now().Format("20060102_150405")
|
|
reportDocx := fmt.Sprintf("Report_%s.docx", timestampStr)
|
|
reportMd := fmt.Sprintf("Report_%s.md", timestampStr)
|
|
|
|
f := docx.NewFile()
|
|
var md strings.Builder
|
|
|
|
addH1 := func(text string) {
|
|
p := f.AddParagraph(); p.AddText(text).Size(20)
|
|
md.WriteString("# " + text + "\n\n")
|
|
}
|
|
addH2 := func(text string) {
|
|
p := f.AddParagraph(); p.AddText(text).Size(14)
|
|
md.WriteString("## " + text + "\n\n")
|
|
}
|
|
addText := func(text string) {
|
|
if text != "" { f.AddParagraph().AddText(text).Size(11) } else { f.AddParagraph() }
|
|
if text != "" { md.WriteString(text + "\n\n") } else { md.WriteString("\n") }
|
|
}
|
|
addBoldText := func(text string) {
|
|
p := f.AddParagraph(); p.AddText("▶ " + text).Size(11)
|
|
md.WriteString("**▶ " + text + "**\n\n")
|
|
}
|
|
addBullet := func(text string) {
|
|
f.AddParagraph().AddText(" • " + text).Size(11)
|
|
md.WriteString("- " + text + "\n")
|
|
}
|
|
addRedBullet := func(text string) {
|
|
p := f.AddParagraph(); p.AddText(" • " + text).Size(11).Color("FF0000")
|
|
md.WriteString("- 🔴 **" + text + "**\n")
|
|
}
|
|
|
|
addH1("시스템 성능 및 장애 원인 분석 리포트")
|
|
addText(fmt.Sprintf("작성 일시: %s", time.Now().Format("2006-01-02 15:04:05")))
|
|
addText("")
|
|
|
|
devBuildCount := 0
|
|
secInterferenceCount := 0
|
|
memSwapCount := 0
|
|
var sumDpcInterfered float64
|
|
|
|
sysKernelHogs := make(map[string]int)
|
|
sysNetworkHogs := make(map[string]int)
|
|
sysNetworkHogsMaxIO := make(map[string]float64)
|
|
sysTargetIps := make(map[string]int)
|
|
sysTargetIpsMaxIO := make(map[string]float64)
|
|
hungCounts := make(map[string]int)
|
|
devToolsStats := make(map[string]*DevToolUsage)
|
|
|
|
// 심화 분석 지표
|
|
hourlyStress := make(map[int]int)
|
|
networkHangCorrels := 0
|
|
totalEventsParsed := 0
|
|
|
|
var details []DetailRecord
|
|
|
|
rows, err := db.Query(`
|
|
SELECT hostname, timestamp, total_cpu_percent, total_mem_percent, dpc_interrupt_percent,
|
|
COALESCE(top_cpu_processes::text, '[]'),
|
|
COALESCE(top_io_processes::text, '[]'),
|
|
COALESCE(network_connections::text, '[]'),
|
|
COALESCE(hung_processes::text, '[]')
|
|
FROM client_metrics
|
|
ORDER BY timestamp DESC LIMIT 10000
|
|
`)
|
|
|
|
if err == nil {
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var r MetricRecord
|
|
err := rows.Scan(&r.Hostname, &r.Timestamp, &r.TotalCpu, &r.TotalMem, &r.DpcInterrupt, &r.TopCpuProcesses, &r.TopIoProcesses, &r.NetworkConnections, &r.HungProcesses)
|
|
if err != nil { continue }
|
|
|
|
localTimeStr := r.Timestamp.Local().Format("2006-01-02 15:04:05")
|
|
|
|
var cpuProcs []ProcessCPU
|
|
json.Unmarshal([]byte(r.TopCpuProcesses), &cpuProcs)
|
|
var ioProcs []ProcessIO
|
|
json.Unmarshal([]byte(r.TopIoProcesses), &ioProcs)
|
|
|
|
// 🚨 [Smoking Gun 타겟팅]
|
|
isCompiling := false
|
|
var activeDevTools []string
|
|
|
|
for _, p := range ioProcs {
|
|
if isDevTool(p.ProcessName) && p.IODataBytesPersec > 1048576 {
|
|
mbps := p.IODataBytesPersec / 1048576.0
|
|
cpuVal := 0.0
|
|
for _, cp := range cpuProcs {
|
|
if cp.ProcessName == p.ProcessName && cp.PID == p.PID {
|
|
cpuVal = cp.CPUPercent; break
|
|
}
|
|
}
|
|
|
|
if stat, ok := devToolsStats[p.ProcessName]; ok {
|
|
stat.Count++
|
|
if cpuVal > stat.MaxCPU { stat.MaxCPU = cpuVal }
|
|
if mbps > stat.MaxIO { stat.MaxIO = mbps }
|
|
} else {
|
|
devToolsStats[p.ProcessName] = &DevToolUsage{ProcessName: p.ProcessName, Count: 1, MaxCPU: cpuVal, MaxIO: mbps}
|
|
}
|
|
|
|
activeDevTools = append(activeDevTools, fmt.Sprintf("%s (CPU: %.1f%%, I/O: %.1f MB/s)", p.ProcessName, cpuVal, mbps))
|
|
isCompiling = true
|
|
}
|
|
}
|
|
|
|
if isCompiling {
|
|
devBuildCount++
|
|
secInterfered := false
|
|
var secCulprits []string
|
|
|
|
if r.DpcInterrupt > 3.0 { secInterfered = true }
|
|
for _, cp := range cpuProcs {
|
|
if isSecProc(cp.ProcessName) && cp.KernelCPUPercent > 2.0 {
|
|
secInterfered = true
|
|
secCulprits = append(secCulprits, fmt.Sprintf("%s (Kernel CPU: %.1f%%)", cp.ProcessName, cp.KernelCPUPercent))
|
|
}
|
|
}
|
|
if secInterfered {
|
|
secInterferenceCount++
|
|
sumDpcInterfered += r.DpcInterrupt
|
|
|
|
rec := DetailRecord{
|
|
Category: fmt.Sprintf("[빌드-보안 충돌] 개발 도구와 보안 솔루션 경합 감지 - 시간: %s | PC: %s", localTimeStr, r.Hostname),
|
|
Content: []string{
|
|
"감지된 개발 프로세스: " + strings.Join(activeDevTools, ", "),
|
|
"관여된 보안 솔루션: " + strings.Join(secCulprits, ", "),
|
|
fmt.Sprintf("발생 커널 오버헤드(DPC): %.1f%%", r.DpcInterrupt),
|
|
},
|
|
}
|
|
details = append(details, rec)
|
|
}
|
|
}
|
|
|
|
if r.TotalMem > 90.0 {
|
|
hasHighIO := false
|
|
for _, p := range ioProcs {
|
|
if p.IODataBytesPersec > 1048576 {
|
|
hasHighIO = true; break
|
|
}
|
|
}
|
|
if hasHighIO { memSwapCount++ }
|
|
}
|
|
|
|
// 상세 내역 및 일반 요약 로직
|
|
isEventOccurred := false
|
|
|
|
// 1. 커널 프리징
|
|
if r.DpcInterrupt > 3.0 {
|
|
isEventOccurred = true
|
|
rec := DetailRecord{Category: fmt.Sprintf("[프리징 유발] 커널 오버헤드 감지 - 시간: %s | PC: %s | 오버헤드: %.1f%%", localTimeStr, r.Hostname, r.DpcInterrupt)}
|
|
for _, cp := range cpuProcs {
|
|
if cp.KernelCPUPercent > 3.0 && !isIgnoredProcess(cp.ProcessName) {
|
|
sysKernelHogs[cp.ProcessName]++
|
|
rec.Content = append(rec.Content, fmt.Sprintf("주범: %s%s (PID: %d) / 커널 점유 %.1f%%", cp.ProcessName, getProcessTag(cp.ProcessName), cp.PID, cp.KernelCPUPercent))
|
|
}
|
|
}
|
|
if len(rec.Content) > 0 { details = append(details, rec) }
|
|
}
|
|
|
|
// 2. 대역폭 포화
|
|
isNetworkChoke := false
|
|
var netRec DetailRecord
|
|
for _, p := range ioProcs {
|
|
if p.IODataBytesPersec > 5242880 && !isIgnoredProcess(p.ProcessName) {
|
|
sysNetworkHogs[p.ProcessName]++
|
|
mbps := p.IODataBytesPersec / 1048576.0
|
|
if mbps > sysNetworkHogsMaxIO[p.ProcessName] { sysNetworkHogsMaxIO[p.ProcessName] = mbps }
|
|
|
|
if !isNetworkChoke {
|
|
isNetworkChoke = true
|
|
isEventOccurred = true
|
|
netRec = DetailRecord{Category: fmt.Sprintf("[대역폭 포화 감지] 네트워크/디스크 지연 - 시간: %s | PC: %s", localTimeStr, r.Hostname)}
|
|
}
|
|
|
|
var conns []NetConn
|
|
json.Unmarshal([]byte(r.NetworkConnections), &conns)
|
|
connStr := "목적지 연결 없음 (내부 대용량 파일 I/O)"
|
|
for _, c := range conns {
|
|
if c.ProcessName == p.ProcessName {
|
|
ipStr := fmt.Sprintf("%s:%d", c.RemoteAddress, c.RemotePort)
|
|
sysTargetIps[ipStr]++
|
|
connMbps := c.IOBytesPerSec / 1048576.0
|
|
if connMbps > sysTargetIpsMaxIO[ipStr] { sysTargetIpsMaxIO[ipStr] = connMbps }
|
|
|
|
connStr = fmt.Sprintf("목적지 IP: %s (속도: %.1f MB/s)", ipStr, connMbps)
|
|
break
|
|
}
|
|
}
|
|
netRec.Content = append(netRec.Content, fmt.Sprintf("트래픽 점유: %s%s (PID: %d) / 총 %.1f MB/s -> %s", p.ProcessName, getProcessTag(p.ProcessName), p.PID, mbps, connStr))
|
|
}
|
|
}
|
|
if isNetworkChoke { details = append(details, netRec) }
|
|
|
|
// 3. 앱 Hang
|
|
var hung []ProcessHung
|
|
json.Unmarshal([]byte(r.HungProcesses), &hung)
|
|
hasValidHang := false
|
|
if len(hung) > 0 {
|
|
hangRec := DetailRecord{Category: fmt.Sprintf("[응답 없음] 프로세스 Hang 발생 - 시간: %s | PC: %s", localTimeStr, r.Hostname)}
|
|
for _, h := range hung {
|
|
if !isIgnoredProcess(h.ProcessName) {
|
|
hungCounts[h.ProcessName]++
|
|
hasValidHang = true
|
|
hangRec.Content = append(hangRec.Content, fmt.Sprintf("멈춤: %s%s (PID: %d)", h.ProcessName, getProcessTag(h.ProcessName), h.PID))
|
|
}
|
|
}
|
|
if hasValidHang {
|
|
details = append(details, hangRec)
|
|
isEventOccurred = true
|
|
}
|
|
}
|
|
|
|
// 심화 분석: 상관관계 및 시간대별 스트레스 추적
|
|
if isNetworkChoke && hasValidHang {
|
|
networkHangCorrels++ // 대역폭 포화가 앱 응답없음을 유발한 연관성 의심 사례
|
|
}
|
|
if isEventOccurred {
|
|
hourlyStress[r.Timestamp.Hour()]++
|
|
}
|
|
totalEventsParsed++
|
|
}
|
|
}
|
|
|
|
// --- Smoking Gun Report Section ---
|
|
addH2("🚨 보안 솔루션 개발 환경 충돌 정밀 분석")
|
|
addText("본 섹션은 보안 프로그램(백신/EDR/DLP)이 개발자의 빌드/컴파일 작업에 미치는 실질적인 성능 저하 연관성을 교차 검증한 결과입니다.")
|
|
addText(fmt.Sprintf("분석 데이터 내 개발 도구(IDE, 컴파일러 등) 활성화 감지: 총 %d 회", devBuildCount))
|
|
addBoldText(fmt.Sprintf("👉 위 빌드 작업 중, 보안 프로그램이 개입하여 커널 프리징/시스템 렉을 유발한 횟수: %d 회", secInterferenceCount))
|
|
|
|
if devBuildCount > 0 {
|
|
rate := (float64(secInterferenceCount) / float64(devBuildCount)) * 100
|
|
addBoldText(fmt.Sprintf("🔥 보안 솔루션으로 인한 개발 업무 방해(병목) 확률: %.1f%%", rate))
|
|
}
|
|
addText("")
|
|
|
|
// --- General Report ---
|
|
addH2("1. 시스템 체감 렉(Lag) 유발 핵심 주범 요약")
|
|
|
|
addBoldText("[프리징 원인] 장애 시점 커널(EDR/백신) 병목 프로세스")
|
|
for i, kv := range sortMap(sysKernelHogs) {
|
|
if i >= 5 { break }
|
|
addBullet(fmt.Sprintf("%s%s (멈춤 유발 횟수: %d회)", kv.Key, getProcessTag(kv.Key), kv.Value))
|
|
}
|
|
if len(sysKernelHogs) == 0 { addBullet("해당 원인 없음") }
|
|
addText("")
|
|
|
|
addBoldText("[지연 원인] 장애 시점 트래픽 폭주 유발 프로세스")
|
|
for i, kv := range sortMap(sysNetworkHogs) {
|
|
if i >= 5 { break }
|
|
maxIo := sysNetworkHogsMaxIO[kv.Key]
|
|
addBullet(fmt.Sprintf("%s%s (포화 유발: %d회 | 최고 I/O 속도: %.1f MB/s)", kv.Key, getProcessTag(kv.Key), kv.Value, maxIo))
|
|
}
|
|
if len(sysNetworkHogs) == 0 { addBullet("해당 원인 없음") }
|
|
addText("")
|
|
|
|
addBoldText("[대역폭 도둑] 렉 유발 핵심 통신 목적지 IP")
|
|
for i, kv := range sortMap(sysTargetIps) {
|
|
if i >= 5 { break }
|
|
maxIo := sysTargetIpsMaxIO[kv.Key]
|
|
addBullet(fmt.Sprintf("%s (접속 빈도: %d회 | 최고 트래픽: %.1f MB/s)", kv.Key, kv.Value, maxIo))
|
|
}
|
|
if len(sysTargetIps) == 0 { addBullet("해당 원인 없음") }
|
|
addText("")
|
|
|
|
addBoldText("만성적 응답 없음(Hang) 발생 애플리케이션")
|
|
for i, kv := range sortMap(hungCounts) {
|
|
if i >= 5 { break }
|
|
addBullet(fmt.Sprintf("%s%s (빈도: %d회)", kv.Key, getProcessTag(kv.Key), kv.Value))
|
|
}
|
|
if len(hungCounts) == 0 { addBullet("해당 원인 없음") }
|
|
addText("")
|
|
|
|
// --- Detailed Logs ---
|
|
addH2("2. 시간대별 상세 이상 징후 발생 이력 (Chronological Log)")
|
|
if len(details) == 0 {
|
|
addText("기록된 이상 징후가 없습니다.")
|
|
addText("")
|
|
} else {
|
|
limit := len(details)
|
|
if limit > 100 { limit = 100 } // 너무 길어지는 것 방지
|
|
for i := 0; i < limit; i++ {
|
|
d := details[i]
|
|
addBoldText(d.Category)
|
|
for _, c := range d.Content { addBullet(c) }
|
|
addText("")
|
|
}
|
|
if len(details) > 100 {
|
|
addText(fmt.Sprintf("... (생략됨: 총 %d건의 이벤트 중 최신 100건만 출력)", len(details)))
|
|
}
|
|
}
|
|
|
|
addH2("3. ETW (.etl) 커널 덤프 정밀 분석 결과")
|
|
var etlFiles []string
|
|
if *etlPath != "" { etlFiles = append(etlFiles, *etlPath)
|
|
} else {
|
|
localFiles, _ := filepath.Glob("*.etl")
|
|
etlFiles = append(etlFiles, localFiles...)
|
|
tempFiles, _ := filepath.Glob("C:\\temp\\*.etl")
|
|
etlFiles = append(etlFiles, tempFiles...)
|
|
}
|
|
|
|
if len(etlFiles) > 0 {
|
|
for _, file := range etlFiles {
|
|
sysMap := parseETL(file)
|
|
addBoldText(fmt.Sprintf("📄 분석 파일: %s", filepath.Base(file)))
|
|
if len(sysMap) > 0 {
|
|
addText("커널 덤프 파일 내에서 가장 많은 인터럽트 및 파일 검사를 유발한 서드파티 커널 드라이버(.sys) 랭킹입니다.")
|
|
for i, kv := range sortMap(sysMap) {
|
|
if i >= 10 { break }
|
|
if isSecDriver(kv.Key) {
|
|
addRedBullet(fmt.Sprintf("%d위: %s (빈도: %d) 🚨[보안 솔루션 커널 드라이버 적발]", i+1, kv.Key, kv.Value))
|
|
} else {
|
|
addBullet(fmt.Sprintf("%d위: %s (빈도: %d)", i+1, kv.Key, kv.Value))
|
|
}
|
|
}
|
|
addText("")
|
|
} else {
|
|
addText("서드파티 드라이버 정보를 추출하지 못했습니다.")
|
|
}
|
|
}
|
|
} else {
|
|
addText("분석할 .etl 커널 덤프 파일이 없습니다.")
|
|
}
|
|
|
|
err = f.Save(reportDocx)
|
|
if err != nil { log.Fatalf("DOCX 파일 저장 실패: %v", err) }
|
|
|
|
err = ioutil.WriteFile(reportMd, []byte(md.String()), 0644)
|
|
if err != nil { log.Fatalf("MD 파일 저장 실패: %v", err) }
|
|
|
|
// --- HTML Report Data Preparation ---
|
|
var rate float64 = 0
|
|
if devBuildCount > 0 {
|
|
rate = (float64(secInterferenceCount) / float64(devBuildCount)) * 100
|
|
}
|
|
|
|
// Calculate advanced metrics
|
|
var avgDpc float64 = 0
|
|
if secInterferenceCount > 0 {
|
|
avgDpc = sumDpcInterfered / float64(secInterferenceCount)
|
|
}
|
|
|
|
healthScore := 100.0
|
|
healthScore -= float64(devBuildCount) * 0.1
|
|
healthScore -= float64(secInterferenceCount) * 1.5
|
|
healthScore -= float64(memSwapCount) * 2.0
|
|
healthScore -= float64(len(hungCounts)) * 1.0
|
|
if healthScore < 0 { healthScore = 0 }
|
|
|
|
// Prepare flat slices for charts
|
|
kernelHogsSlice := sortMap(sysKernelHogs)
|
|
networkHogsSlice := sortMap(sysNetworkHogs)
|
|
targetIpsSlice := sortMap(sysTargetIps)
|
|
hungCountsSlice := sortMap(hungCounts)
|
|
|
|
var etlDriversSlice []kv
|
|
if len(etlFiles) > 0 {
|
|
sysMap := parseETL(etlFiles[0])
|
|
etlDriversSlice = sortMap(sysMap)
|
|
}
|
|
|
|
var devStatsSlice []DevToolUsage
|
|
for _, v := range devToolsStats {
|
|
devStatsSlice = append(devStatsSlice, *v)
|
|
}
|
|
|
|
var hourlyStressSlice []kv
|
|
for i := 0; i < 24; i++ {
|
|
hourlyStressSlice = append(hourlyStressSlice, kv{Key: fmt.Sprintf("%02d:00", i), Value: hourlyStress[i]})
|
|
}
|
|
|
|
reportData := ReportData{
|
|
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
|
|
DevBuildCount: devBuildCount,
|
|
SecInterferenceCount: secInterferenceCount,
|
|
InterferenceRate: rate,
|
|
KernelHogs: kernelHogsSlice,
|
|
NetworkHogs: networkHogsSlice,
|
|
TargetIps: targetIpsSlice,
|
|
HungCounts: hungCountsSlice,
|
|
Details: details,
|
|
EtlDrivers: etlDriversSlice,
|
|
MemSwapEvents: memSwapCount,
|
|
AvgDpcWhenInterfered: avgDpc,
|
|
DevToolsStats: devStatsSlice,
|
|
VDIHealthScore: healthScore,
|
|
HourlyStress: hourlyStressSlice,
|
|
NetworkHangCorrels: networkHangCorrels,
|
|
}
|
|
|
|
reportHtml := fmt.Sprintf("Report_%s.html", timestampStr)
|
|
err = generateHTMLReport(reportHtml, reportData)
|
|
if err != nil {
|
|
log.Printf("HTML 파일 저장 실패: %v", err)
|
|
}
|
|
|
|
fmt.Printf("==================================================\n")
|
|
fmt.Printf(" 분석 완료: '%s', '%s', '%s' 문서가 생성되었습니다.\n", reportDocx, reportMd, reportHtml)
|
|
fmt.Printf("==================================================\n")
|
|
}
|
|
|
|
func parseETL(etlPath string) map[string]int {
|
|
sysCounts := make(map[string]int)
|
|
dumpFile := "etl_dump.xml"
|
|
cmd := exec.Command("tracerpt.exe", etlPath, "-o", dumpFile, "-of", "XML", "-y")
|
|
cmd.Run()
|
|
data, err := ioutil.ReadFile(dumpFile)
|
|
if err != nil { return sysCounts }
|
|
re := regexp.MustCompile(`(?i)([a-zA-Z0-9_-]+\.sys)`)
|
|
matches := re.FindAllString(string(data), -1)
|
|
ignoreList := map[string]bool{
|
|
"ntoskrnl.sys": true, "ndis.sys": true, "tcpip.sys": true, "fltmgr.sys": true,
|
|
"wof.sys": true, "ntfs.sys": true, "dxgkrnl.sys": true, "netbt.sys": true,
|
|
}
|
|
for _, match := range matches {
|
|
match = strings.ToLower(match)
|
|
if !ignoreList[match] { sysCounts[match]++ }
|
|
}
|
|
os.Remove(dumpFile)
|
|
os.Remove("summary.txt")
|
|
return sysCounts
|
|
}
|