Plotter Cheatsheet¶
- [Kopieren auf Clipboard](#copy-to-clipboard___
- [PDF herunterladen](#download-pdf_*
Überblick¶
PingPlotter ist ein leistungsstarkes Netzwerk-Fehlersuche und Monitoring-Tool, das die Funktionalität von Ping und Traceroute mit fortschrittlichen Visualisierungsfunktionen kombiniert. Es bietet Echtzeit-Netzwerk-Performance-Überwachung, hilft, Netzwerkprobleme, Engpässe und intermittierende Probleme zu identifizieren, die traditionelle Werkzeuge vermissen könnten.
Schlüsselmerkmale¶
- **Visual Traceroute*: Grafische Darstellung von Netzwerkpfaden und Performance
- ** Ständige Überwachung** Langzeit-Netzwerk-Performance-Tracking
- **Packet Loss Detection*: Intermittierende Verbindungsprobleme identifizieren
- **Latency Analysis*: Detaillierte Zeitmessungen
- **Historische Daten*: Speichern und Analysieren der Netzwerkleistung im Laufe der Zeit
- **Alerting System*: Meldungen für Netzprobleme und -schwellen
- **Multi-Target Monitoring*: Mehrere Ziele gleichzeitig überwachen
- Reporting: Detaillierte Netzwerkleistungsberichte erstellen
Installation¶
Windows Installation¶
```powershell
Download PingPlotter from official website¶
https://www.pingplotter.com/download¶
Silent installation (Pro/Professional versions)¶
PingPlotterSetup.exe /S /v"/qn"
Standard installation¶
1. Download installer¶
2. Run as administrator¶
3. Follow installation wizard¶
4. Enter license key (for paid versions)¶
Verify installation¶
Get-Process | Where-Object {$_.ProcessName -eq "PingPlotter"}
Check installation directory¶
Get-ChildItem "C:\Program Files\PingPlotter Pro" ```_
Installation der Kommandozeile¶
```bash
Using Chocolatey (Windows)¶
choco install pingplotter
Using Winget (Windows)¶
winget install PingPlotter.PingPlotter
Verify installation¶
pingplotter --version ```_
Lizenzkonfiguration¶
```powershell
Configure license (Pro/Professional)¶
Help → Enter License Key¶
Or via command line:¶
pingplotter.exe -license "YOUR-LICENSE-KEY"
Check license status¶
pingplotter.exe -license-info
Offline activation (air-gapped systems)¶
1. Generate activation request¶
pingplotter.exe -activation-request > activation_request.txt
2. Submit request to PingPlotter support¶
3. Apply activation response¶
pingplotter.exe -activation-response activation_response.txt ```_
Basisnutzung¶
Netzwerküberwachung starten¶
```bash
Launch PingPlotter GUI¶
pingplotter.exe
Command line monitoring¶
pingplotter.exe -target google.com -samples 100
Monitor specific IP address¶
pingplotter.exe -target 8.8.8.8 -interval 2.5
Monitor with custom packet size¶
pingplotter.exe -target example.com -packetsize 1024
Save results to file¶
pingplotter.exe -target google.com -samples 50 -output results.pp2 ```_
GUI Basic Operations¶
```powershell
Basic monitoring setup¶
1. Enter target address in "Address to trace" field¶
2. Click "Start" button¶
3. Monitor real-time results in timeline graph¶
Configure monitoring parameters¶
Edit → Preferences → Trace Options¶
- Trace Interval: 2.5 seconds (default)¶
- Packet Size: 32 bytes (default)¶
- Timeout: 3000ms (default)¶
- Max Hops: 30 (default)¶
Multiple target monitoring¶
File → New Target¶
Enter additional target addresses¶
Each target gets separate timeline¶
Save monitoring session¶
File → Save As → session.pp2¶
Load previous session¶
File → Open → session.pp2¶
```_
Zielkonfiguration¶
```bash
DNS name resolution¶
pingplotter.exe -target www.example.com
IPv4 address¶
pingplotter.exe -target 192.168.1.1
IPv6 address¶
pingplotter.exe -target 2001:4860:4860::8888
Custom port (for TCP traces)¶
pingplotter.exe -target example.com:80 -protocol tcp
Multiple targets in batch file¶
echo "google.com" > targets.txt echo "cloudflare.com" >> targets.txt echo "8.8.8.8" >> targets.txt pingplotter.exe -targetfile targets.txt ```_
Erweiterte Konfiguration¶
Trace Optionen¶
```powershell
Advanced trace configuration¶
Edit → Preferences → Trace Options¶
Packet settings¶
$traceConfig = @{ PacketSize = 64 # Bytes (32-1472) TraceInterval = 1.0 # Seconds (0.5-3600) Timeout = 5000 # Milliseconds MaxHops = 25 # Maximum trace hops Protocol = "ICMP" # ICMP, UDP, TCP }
DNS settings¶
$dnsConfig = @{ ReverseDNS = $true # Resolve IP to hostname DNSTimeout = 2000 # DNS resolution timeout PreferIPv4 = $true # IPv4 preference UseSystemDNS = $true # Use system DNS servers }
Performance settings¶
$perfConfig = @{ HighResolution = $true # High-resolution timing CPUPriority = "Normal" # Process priority NetworkBuffer = 8192 # Network buffer size MaxSamples = 10000 # Maximum samples to store } ```_
Konfiguration aktivieren¶
```powershell
Configure alerts¶
Tools → Alerts¶
Latency alert¶
$latencyAlert = @{ Name = "High Latency Alert" Condition = "Average latency > 200ms" Duration = "5 minutes" Action = "Email notification" Recipients = "admin@company.com" }
Packet loss alert¶
$packetLossAlert = @{ Name = "Packet Loss Alert" Condition = "Packet loss > 5%" Duration = "2 minutes" Action = "SNMP trap" Community = "public" Target = "192.168.1.100" }
Outage alert¶
$outageAlert = @{ Name = "Network Outage" Condition = "100% packet loss" Duration = "30 seconds" Action = "Run script" Script = "C:\Scripts\network_outage.bat" }
Email configuration¶
$emailConfig = @{ SMTPServer = "smtp.company.com" Port = 587 Username = "alerts@company.com" Password = "encrypted_password" SSL = $true From = "pingplotter@company.com" } ```_
Multi-Target Monitoring¶
```bash
Configure multiple targets¶
File → Multi-Target List¶
Create target list file¶
cat > monitoring_targets.txt << EOF
Critical Infrastructure¶
google.com,Primary DNS 8.8.8.8,Google DNS cloudflare.com,CDN Provider 192.168.1.1,Gateway Router 10.0.0.1,Internal Server EOF
Load target list¶
pingplotter.exe -targetfile monitoring_targets.txt
Automated target management¶
pingplotter.exe -target-add "new-server.com" pingplotter.exe -target-remove "old-server.com" pingplotter.exe -target-list
Group targets by category¶
Infrastructure group¶
pingplotter.exe -group "Infrastructure" -target-add "router.company.com" pingplotter.exe -group "Infrastructure" -target-add "switch.company.com"
External services group¶
pingplotter.exe -group "External" -target-add "api.service.com" pingplotter.exe -group "External" -target-add "cdn.provider.com" ```_
Datenanalyse und Visualisierung¶
Zeitanalyse¶
```powershell
Timeline graph interpretation¶
Green bars: Good performance (low latency)¶
Yellow bars: Moderate latency¶
Red bars: High latency or packet loss¶
Black bars: Complete packet loss¶
Timeline navigation¶
Zoom in: Ctrl + Mouse wheel up¶
Zoom out: Ctrl + Mouse wheel down¶
Pan: Click and drag timeline¶
Reset view: Ctrl + 0¶
Time range selection¶
$timeRanges = @{ "Last Hour" = "1h" "Last 4 Hours" = "4h" "Last Day" = "24h" "Last Week" = "7d" "Custom Range" = "Select start/end times" }
Statistical analysis¶
View → Statistics Window¶
Shows min/max/average latency per hop¶
Packet loss percentage¶
Standard deviation¶
Jitter measurements¶
```_
Routenanalyse¶
```bash
Analyze network path¶
Focus on specific hops showing issues¶
Right-click hop → Properties¶
Hop analysis metrics¶
echo "Hop Analysis Checklist:" echo "1. Latency consistency" echo "2. Packet loss patterns" echo "3. DNS resolution time" echo "4. Route stability" echo "5. Geographic location"
Identify problem areas¶
High latency at specific hop = bottleneck¶
Packet loss at multiple hops = upstream issue¶
Intermittent issues = congestion or hardware problems¶
Route changes = routing instability¶
```_
Performance Metrics¶
```powershell
Key performance indicators¶
$performanceMetrics = @{ # Latency metrics MinLatency = "Minimum round-trip time" MaxLatency = "Maximum round-trip time" AvgLatency = "Average round-trip time" Jitter = "Latency variation (standard deviation)"
# Reliability metrics
PacketLoss = "Percentage of lost packets"
Availability = "Percentage of successful pings"
MTBF = "Mean time between failures"
MTTR = "Mean time to recovery"
# Quality metrics
MOS = "Mean Opinion Score (VoIP quality)"
RTT = "Round-trip time consistency"
Throughput = "Effective bandwidth utilization"
Stability = "Route consistency over time"
}
Generate performance report¶
Tools → Summary Report¶
Select time range and metrics¶
Export to PDF, HTML, or CSV¶
```_
Automatisierung und Schrift¶
Befehlszeilenautomatisierung¶
```bash
!/bin/bash¶
pingplotter_automation.sh¶
Configuration¶
TARGET_LIST="targets.txt" OUTPUT_DIR="/var/log/pingplotter" REPORT_EMAIL="admin@company.com" ALERT_THRESHOLD=200 # ms
Create output directory¶
mkdir -p "$OUTPUT_DIR"
Function to monitor single target¶
monitor_target() { local target=\(1 local duration=\)2 local output_file="\(OUTPUT_DIR/\)$(date +%Y%m%d%H%M%S).pp2"
echo "Starting monitoring for $target..."
# Start PingPlotter monitoring
pingplotter.exe \
-target "$target" \
-samples "$duration" \
-interval 2.5 \
-output "$output_file" \
-autostart \
-minimize
# Wait for completion
while pgrep -f "pingplotter.*$target" > /dev/null; do
sleep 10
done
echo "Monitoring completed for $target"
# Analyze results
analyze_results "$output_file" "$target"
}
Function to analyze results¶
analyze_results() { local file=\(1 local target=\)2
# Extract statistics (requires PingPlotter Pro)
pingplotter.exe -analyze "$file" -export-csv "$OUTPUT_DIR/${target}_stats.csv"
# Check for alerts
local avg_latency=$(awk -F',' 'NR>1 {sum+=$3; count++} END {print sum/count}' "$OUTPUT_DIR/${target}_stats.csv")
if (( $(echo "$avg_latency > $ALERT_THRESHOLD" | bc -l) )); then
send_alert "$target" "$avg_latency"
fi
}
Function to send alerts¶
send_alert() { local target=\(1 local latency=\)2
local subject="Network Alert: High latency to $target"
local body="Average latency to $target: ${latency}ms (threshold: ${ALERT_THRESHOLD}ms)"
echo "$body" | mail -s "$subject" "$REPORT_EMAIL"
# Log alert
echo "$(date): ALERT - $target latency: ${latency}ms" >> "$OUTPUT_DIR/alerts.log"
}
Main monitoring loop¶
main() { echo "Starting automated PingPlotter monitoring..."
# Read targets from file
while IFS= read -r target; do
# Skip comments and empty lines
[[ "$target" =~ ^#.*$ ]] && continue
[[ -z "$target" ]] && continue
# Start monitoring in background
monitor_target "$target" 1440 & # 24 hours of monitoring
# Prevent overwhelming the system
sleep 5
done < "$TARGET_LIST"
# Wait for all monitoring to complete
wait
echo "All monitoring tasks completed"
# Generate summary report
generate_summary_report
}
Function to generate summary report¶
generate_summary_report() { local report_file="\(OUTPUT_DIR/summary_\)(date +%Y%m%d).html"
cat > "$report_file" << EOF
Network Performance Summary
Generated: $(date)
Target Performance
| Target | Avg Latency (ms) | Packet Loss (%) | Status |
|---|---|---|---|
| $target | $(printf "%.2f" "$avg_latency") | $(printf "%.2f" "$packet_loss") | $status |
Recent Alerts
$(tail -20 "$OUTPUT_DIR/alerts.log" 2>/dev/null || echo "No recent alerts")
EOF
echo "Summary report generated: $report_file"
# Email the report
if command -v mutt >/dev/null; then
mutt -s "PingPlotter Summary Report" -a "$report_file" -- "$REPORT_EMAIL" < /dev/null
fi
}
Run main function¶
main "$@" ```_
Integration von PowerShell¶
```powershell
PingPlotter PowerShell automation¶
PingPlotter-Automation.ps1¶
param( [string[]]\(Targets = @("google.com", "cloudflare.com"), [int]\)Duration = 60, # minutes [string]\(OutputPath = "C:\PingPlotter\Reports", [string]\)AlertEmail = "admin@company.com" )
Ensure output directory exists¶
if (!(Test-Path $OutputPath)) { New-Item -ItemType Directory -Path $OutputPath -Force }
Function to start PingPlotter monitoring¶
function Start-PingPlotterMonitoring { param( [string]\(Target, [int]\)DurationMinutes, [string]$OutputFile )
$arguments = @(
"-target", $Target,
"-samples", ($DurationMinutes * 24), # 2.5s interval = 24 samples/minute
"-interval", "2.5",
"-output", $OutputFile,
"-autostart",
"-minimize"
)
Write-Host "Starting monitoring for $Target..."
$process = Start-Process -FilePath "pingplotter.exe" -ArgumentList $arguments -PassThru
return $process
}
Function to analyze PingPlotter results¶
function Analyze-PingPlotterResults { param( [string]\(ResultFile, [string]\)Target )
# Export statistics to CSV
$csvFile = $ResultFile -replace "\.pp2$", "_stats.csv"
$arguments = @("-analyze", $ResultFile, "-export-csv", $csvFile)
Start-Process -FilePath "pingplotter.exe" -ArgumentList $arguments -Wait
if (Test-Path $csvFile) {
# Import and analyze CSV data
$data = Import-Csv $csvFile
$stats = @{
Target = $Target
AvgLatency = ($data | Measure-Object -Property Latency -Average).Average
MaxLatency = ($data | Measure-Object -Property Latency -Maximum).Maximum
MinLatency = ($data | Measure-Object -Property Latency -Minimum).Minimum
PacketLoss = ($data | Measure-Object -Property PacketLoss -Average).Average
SampleCount = $data.Count
}
return $stats
}
return $null
}
Function to send email alerts¶
function Send-Alert { param( [string]\(Target, [hashtable]\)Stats, [string]$ToEmail )
$subject = "PingPlotter Alert: Issues detected for $Target"
$body = @"
Network performance alert for target: $Target
Statistics: - Average Latency: \((\)Stats.AvgLatency) ms - Maximum Latency: \((\)Stats.MaxLatency) ms - Minimum Latency: \((\)Stats.MinLatency) ms - Packet Loss: \((\)Stats.PacketLoss)% - Sample Count: \((\)Stats.SampleCount)
Please investigate network connectivity to this target.
Generated by PingPlotter automation script. "@
try {
Send-MailMessage -To $ToEmail -Subject $subject -Body $body -SmtpServer "smtp.company.com"
Write-Host "Alert sent for $Target"
}
catch {
Write-Error "Failed to send alert: $_"
}
}
Function to generate HTML report¶
function Generate-HTMLReport { param( [hashtable[]]\(AllStats, [string]\)OutputPath )
$reportFile = Join-Path $OutputPath "PingPlotter_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"
$html = @"
PingPlotter Performance Report
Report Summary
Generated: $(Get-Date)
Monitoring Duration: $Duration minutes
Targets Monitored: $($AllStats.Count)
Performance Results
| Target | Avg Latency (ms) | Max Latency (ms) | Min Latency (ms) | Packet Loss (%) | Samples | Status |
|---|---|---|---|---|---|---|
| $($stat.Target) | $([math]::Round($stat.AvgLatency, 2)) | $([math]::Round($stat.MaxLatency, 2)) | $([math]::Round($stat.MinLatency, 2)) | $([math]::Round($stat.PacketLoss, 2)) | $($stat.SampleCount) | $status |
Performance Recommendations
- Latency < 50ms: Excellent performance
- Latency 50-150ms: Good performance
- Latency 150-300ms: Acceptable performance
- Latency > 300ms: Poor performance - investigate
- Packet Loss > 1%: Network issues - investigate
"@
$html | Out-File -FilePath $reportFile -Encoding UTF8
Write-Host "HTML report generated: $reportFile"
return $reportFile
}
Main execution¶
Write-Host "Starting PingPlotter automation for \((\)Targets.Count) targets..."
$processes = @() $resultFiles = @()
Start monitoring for each target¶
foreach ($target in $Targets) { $timestamp = Get-Date -Format "yyyyMMdd_HHmmss" \(outputFile = Join-Path \(OutputPath "\)_\).pp2"
$process = Start-PingPlotterMonitoring -Target $target -DurationMinutes $Duration -OutputFile $outputFile
$processes += @{
Process = $process
Target = $target
OutputFile = $outputFile
}
$resultFiles += $outputFile
# Small delay to prevent overwhelming the system
Start-Sleep -Seconds 2
}
Wait for all monitoring to complete¶
Write-Host "Waiting for monitoring to complete..." foreach ($item in $processes) { $item.Process.WaitForExit() Write-Host "Monitoring completed for \((\)item.Target)" }
Analyze results¶
Write-Host "Analyzing results..." $allStats = @()
foreach ($item in $processes) { if (Test-Path $item.OutputFile) { $stats = Analyze-PingPlotterResults -ResultFile $item.OutputFile -Target $item.Target
if ($stats) {
$allStats += $stats
# Check for alerts
if ($stats.AvgLatency -gt 200 -or $stats.PacketLoss -gt 1) {
Send-Alert -Target $item.Target -Stats $stats -ToEmail $AlertEmail
}
}
}
}
Generate report¶
if ($allStats.Count -gt 0) { $reportFile = Generate-HTMLReport -AllStats $allStats -OutputPath $OutputPath
# Display summary
Write-Host "`nMonitoring Summary:"
Write-Host "==================="
foreach ($stat in $allStats) {
$status = if ($stat.PacketLoss -gt 1) { "ALERT" } elseif ($stat.AvgLatency -gt 200) { "WARNING" } else { "OK" }
Write-Host "$($stat.Target): Avg $([math]::Round($stat.AvgLatency, 2))ms, Loss $([math]::Round($stat.PacketLoss, 2))% - $status"
}
Write-Host "`nReport saved to: $reportFile"
} else { Write-Warning "No results to analyze. Check PingPlotter installation and target accessibility." }
Write-Host "PingPlotter automation completed." ```_
Integration mit anderen Tools¶
SNMP Integration¶
```powershell
SNMP monitoring integration¶
Requires SNMP tools and PingPlotter Pro¶
Configure SNMP alerts¶
$snmpConfig = @{ Community = "public" Version = "2c" Target = "192.168.1.100" Port = 162 }
SNMP trap for network alerts¶
function Send-SNMPTrap { param( [string]\(Target, [string]\)Message, [hashtable]$Config )
$oid = "1.3.6.1.4.1.12345.1.1" # Custom OID for PingPlotter alerts
snmptrap -v $Config.Version -c $Config.Community $Config.Target:$Config.Port $oid s "$Message"
}
Integration script¶
$alertMessage = "High latency detected: $Target - \((\)stats.AvgLatency)ms" Send-SNMPTrap -Target $target -Message $alertMessage -Config $snmpConfig ```_
Syslog Integration¶
```bash
!/bin/bash¶
Syslog integration for PingPlotter alerts¶
SYSLOG_SERVER="192.168.1.50" SYSLOG_PORT=514 FACILITY="local0" SEVERITY="warning"
Function to send syslog message¶
send_syslog() { local target=\(1 local latency=\)2 local packet_loss=$3
local message="PingPlotter Alert: Target=$target, Latency=${latency}ms, PacketLoss=${packet_loss}%"
# Send to remote syslog server
logger -n "$SYSLOG_SERVER" -P "$SYSLOG_PORT" -p "${FACILITY}.${SEVERITY}" "$message"
# Also log locally
logger -t "pingplotter" "$message"
}
Example usage¶
send_syslog "google.com" "250" "2.5" ```_
Datenbankintegration¶
```python
!/usr/bin/env python3¶
Database integration for PingPlotter data¶
import sqlite3 import csv import datetime import os
class PingPlotterDB: def init(self, db_path="pingplotter.db"): self.db_path = db_path self.init_database()
def init_database(self):
"""Initialize database schema"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS network_performance (
id INTEGER PRIMARY KEY AUTOINCREMENT,
target TEXT NOT NULL,
timestamp DATETIME NOT NULL,
hop_number INTEGER,
hop_ip TEXT,
hop_hostname TEXT,
latency REAL,
packet_loss REAL,
jitter REAL
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS alerts (
id INTEGER PRIMARY KEY AUTOINCREMENT,
target TEXT NOT NULL,
alert_type TEXT NOT NULL,
message TEXT,
timestamp DATETIME NOT NULL,
resolved BOOLEAN DEFAULT FALSE
)
''')
cursor.execute('''
CREATE INDEX IF NOT EXISTS idx_target_timestamp
ON network_performance(target, timestamp)
''')
conn.commit()
conn.close()
def import_csv_data(self, csv_file, target):
"""Import PingPlotter CSV export data"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
with open(csv_file, 'r') as f:
reader = csv.DictReader(f)
for row in reader:
cursor.execute('''
INSERT INTO network_performance
(target, timestamp, hop_number, hop_ip, hop_hostname, latency, packet_loss, jitter)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
''', (
target,
datetime.datetime.now(),
row.get('Hop', 0),
row.get('IP', ''),
row.get('Hostname', ''),
float(row.get('Latency', 0)),
float(row.get('PacketLoss', 0)),
float(row.get('Jitter', 0))
))
conn.commit()
conn.close()
print(f"Imported data from {csv_file} for target {target}")
def log_alert(self, target, alert_type, message):
"""Log network alert"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute('''
INSERT INTO alerts (target, alert_type, message, timestamp)
VALUES (?, ?, ?, ?)
''', (target, alert_type, message, datetime.datetime.now()))
conn.commit()
conn.close()
def get_performance_summary(self, target, hours=24):
"""Get performance summary for target"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
since = datetime.datetime.now() - datetime.timedelta(hours=hours)
cursor.execute('''
SELECT
AVG(latency) as avg_latency,
MIN(latency) as min_latency,
MAX(latency) as max_latency,
AVG(packet_loss) as avg_packet_loss,
COUNT(*) as sample_count
FROM network_performance
WHERE target = ? AND timestamp > ?
''', (target, since))
result = cursor.fetchone()
conn.close()
if result:
return {
'target': target,
'avg_latency': result[0],
'min_latency': result[1],
'max_latency': result[2],
'avg_packet_loss': result[3],
'sample_count': result[4],
'period_hours': hours
}
return None
def generate_report(self, output_file="performance_report.html"):
"""Generate HTML performance report"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
# Get all targets
cursor.execute('SELECT DISTINCT target FROM network_performance')
targets = [row[0] for row in cursor.fetchall()]
html = """
<!DOCTYPE html>
<html>
<head>
<title>Network Performance Report</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
table { border-collapse: collapse; width: 100%; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background-color: #f2f2f2; }
.good { background-color: #d4edda; }
.warning { background-color: #fff3cd; }
.alert { background-color: #f8d7da; }
</style>
</head>
<body>
<h1>Network Performance Report</h1>
<p>Generated: {}</p>
<table>
<tr>
<th>Target</th>
<th>Avg Latency (ms)</th>
<th>Min Latency (ms)</th>
<th>Max Latency (ms)</th>
<th>Packet Loss (%)</th>
<th>Samples</th>
<th>Status</th>
</tr>
""".format(datetime.datetime.now())
for target in targets:
summary = self.get_performance_summary(target)
if summary:
status_class = "good"
status = "Good"
if summary['avg_packet_loss'] > 1:
status_class = "alert"
status = "Packet Loss"
elif summary['avg_latency'] > 200:
status_class = "warning"
status = "High Latency"
html += f"""
<tr class="{status_class}">
<td>{target}</td>
<td>{summary['avg_latency']:.2f}</td>
<td>{summary['min_latency']:.2f}</td>
<td>{summary['max_latency']:.2f}</td>
<td>{summary['avg_packet_loss']:.2f}</td>
<td>{summary['sample_count']}</td>
<td>{status}</td>
</tr>
"""
html += """
</table>
</body>
</html>
"""
with open(output_file, 'w') as f:
f.write(html)
conn.close()
print(f"Report generated: {output_file}")
Example usage¶
if name == "main": db = PingPlotterDB()
# Import sample data
# db.import_csv_data("google_com_stats.csv", "google.com")
# Log sample alert
db.log_alert("google.com", "high_latency", "Average latency exceeded 200ms")
# Generate report
db.generate_report()
```_
Fehlerbehebung¶
Gemeinsame Themen¶
```powershell
PingPlotter not starting¶
1. Check if already running¶
Get-Process | Where-Object {$_.ProcessName -eq "PingPlotter"}
2. Run as administrator¶
Start-Process "pingplotter.exe" -Verb RunAs
3. Check Windows Firewall¶
netsh advfirewall firewall show rule name="PingPlotter"
4. Verify license (Pro versions)¶
pingplotter.exe -license-info
ICMP blocked by firewall¶
1. Allow ICMP in Windows Firewall¶
netsh advfirewall firewall add rule name="ICMP Allow incoming V4 echo request" protocol=icmpv4:8,any dir=in action=allow
2. Check router/firewall settings¶
Ensure ICMP echo requests are allowed¶
3. Test with different protocols¶
Try UDP or TCP traces if ICMP is blocked¶
High CPU usage¶
1. Reduce trace frequency¶
Edit → Preferences → Trace Options → Trace Interval: 5 seconds¶
2. Limit number of targets¶
Monitor fewer targets simultaneously¶
3. Reduce sample history¶
Edit → Preferences → General → Max samples to keep: 1000¶
Inaccurate results¶
1. Check system time synchronization¶
w32tm /query /status
2. Verify network adapter settings¶
Disable power management on network adapter¶
3. Close bandwidth-intensive applications¶
Ensure clean network conditions during testing¶
```_
Leistungsoptimierung¶
```bash
Optimize PingPlotter performance¶
1. System optimization¶
echo "Optimizing system for network monitoring..."
Disable unnecessary services¶
sc config "Windows Search" start= disabled sc config "Superfetch" start= disabled
Set high performance power plan¶
powercfg -setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c
Increase network buffer sizes¶
netsh int tcp set global autotuninglevel=normal netsh int tcp set global chimney=enabled netsh int tcp set global rss=enabled
2. PingPlotter optimization¶
Edit PingPlotter.exe.config¶
cat > PingPlotter.exe.config << EOF
3. Network adapter optimization¶
Disable power management¶
powershell "Get-NetAdapter | ForEach-Object { Disable-NetAdapterPowerManagement -Name $_.Name }"
Set interrupt moderation¶
netsh int tcp set global rsc=disabled ```_
Dieses umfassende PingPlotter-Catsheet bietet alles, was für professionelle Netzwerk-Fehlersuche, Leistungsüberwachung und automatisierte Netzwerkanalysen benötigt wird, von Basis-Ping-Operationen bis hin zu fortschrittlichen Automatisierungs- und Integrationsszenarien.