The Windows Network Performance Counters Worth Collecting
Open Performance Monitor on any Windows machine and you will find yourself in front of one of the largest measurement catalogs in computing. It holds thousands of performance counters, the operating system's continuously updated statistics about everything it is doing. Somewhere in that haystack are about a dozen numbers that describe the machine's network life with real precision. They describe how much it is talking, whether the wire is damaging its packets, and whether it is quietly resending data. That resending happens because something on the path keeps losing it.
The problem is not access — the counters are free, built in, and readable with tools already on the box. The problem is selection, and interpretation. Nearly every network counter has a classic misread: a way that reasonable people look at it and conclude something false. Bytes get mistaken for bits. A queue counter that reports zero forever gets read as eternal health. A lifetime total gets read as a current crisis.
This guide teaches the short list worth collecting and, for each counter, the misread to avoid. By the end you will be able to browse the catalog confidently and pull any counter from the command line. You will be able to read the dozen that matter the way an experienced admin does.
In this guide
- How counters are addressed: objects, counters, instances
- Browsing and collecting: PerfMon, typeperf, Get-Counter
- Throughput: the bytes-versus-bits trap
- Saturation: the queue that always reads zero
- Errors and discards: the physical evidence
- TCP health: retransmits and the ratio that matters
- The supporting cast: UDP, DNS, and DPC time
- Collection discipline
- The keep-list, on one table
How counters are addressed: objects, counters, instances
Every counter has a three-part address, and once you see the pattern you can navigate the whole catalog. The address looks like this:
\Network Interface(Intel Ethernet Adapter _1)\Bytes Total/sec
\______________/ \______________________/ \_______________/
object instance counter
The object is the category — a component of the system, like Network Interface, TCPv4, or Processor. The counter is the specific measurement within that category. The instance, in parentheses, answers "which one?" when the machine has several of a thing: each network adapter is its own instance, each processor core is its own instance. Objects that measure something singular (like TCPv4 — the machine has one TCP stack) have no instances at all.
Two instance habits will save you grief. First, instance names for network adapters come from the driver's descriptive name, not the friendly "Ethernet" label you see in network settings. Characters like parentheses and slashes in the driver name get swapped for brackets and underscores in the instance name. Always list the real instance names before scripting against them. Second, many objects offer a _Total instance that sums or averages all the others. It is convenient and it is a trap. On a machine with one busy adapter and five idle virtual ones, _Total dilutes the story. For a counter like utilization an average across adapters means nothing. Collect per-instance; use _Total only when "everything combined" is genuinely the question.
Browsing and collecting: PerfMon, typeperf, Get-Counter
Three tools, three jobs. Performance Monitor (perfmon) is for exploring. The Add Counters dialog shows every object, counter, and instance on the machine, with a "show description" box that explains each one. Browse there first; script later. For scripting, typeperf is the classic command-line collector. List what exists, then sample:
# What instances does the Network Interface object have? typeperf -qx "Network Interface" | more # Sample one counter every 5 seconds, 6 times typeperf "\Network Interface(*)\Bytes Total/sec" -si 5 -sc 6 "10:14:05","842113.42" "10:14:10","910277.85" "10:14:15","1287345.02"
Each line is a timestamped reading in bytes per second (timestamps trimmed here for readability). Add -o results.csv -f CSV and typeperf becomes a free logging tool. The PowerShell equivalent, Get-Counter, returns objects you can filter and do math on:
Get-Counter '\TCPv4\Segments Retransmitted/sec' -SampleInterval 15 -MaxSamples 4 Timestamp CounterSamples --------- -------------- 10:14:05 \\fs01\tcpv4\segments retransmitted/sec : 2.13 10:14:20 \\fs01\tcpv4\segments retransmitted/sec : 1.87
One mechanical note that explains a lot: most counters you care about are stored internally as ever-climbing totals. And the "/sec" versions you read are computed by taking two readings and dividing the difference by the time between them. The tools do this for you — which is why the very first sample from some tools is meaningless or zero. It had nothing to subtract yet.
Throughput: the bytes-versus-bits trap
The workhorse is \Network Interface(nic)\Bytes Total/sec — all traffic in and out of the adapter — with Bytes Received/sec and Bytes Sent/sec splitting the directions. This is the counter behind the question "how busy is this machine's network connection?"
Now the misread that bites everyone at least once: this counter is in bytes, but link speeds are in bits. A gigabit link carries 1,000,000,000 bits per second, which is 125,000,000 bytes per second. So when Bytes Total/sec reads 120,000,000 on a gigabit adapter, the link is not at 12% — it is at roughly 96% and gasping. Multiply the counter by 8 before comparing to any link speed. Admins who skip the ×8 conclude "the network is barely used" while staring directly at a saturated link. It happens constantly because both numbers are just large integers with no units attached.
The comparison partner is Current Bandwidth, which reports the adapter's negotiated speed in bits per second — 1,000,000,000 for a healthy gigabit link. It earns its keep twice. First, it gives you the denominator for a proper utilization calculation: utilization = (Bytes Total/sec × 8) ÷ Current Bandwidth. Second, it is a diagnostic in itself: a gigabit adapter reporting 100,000,000 has auto-negotiated down to 100 megabits, usually because of a damaged cable or a mismatched switch port. That is a silent tenfold slowdown that this one counter exposes instantly. Utilization math has one honest caveat. Full-duplex links can carry line rate in each direction simultaneously. So for precision work compare each direction's byte counter against the link speed rather than the combined total.
Saturation: the queue that always reads zero
Output Queue Length claims to report how many packets are waiting in line to be transmitted — the classic sign of a send path that cannot keep up. Old guidance says sustained values above a couple of packets mean trouble, and on systems where the counter works, that remains fair.
The misread is subtle: on many modern systems this counter reports zero regardless of reality. Queuing on current NICs largely happens down in the driver and hardware layers that this counter never sees. So a permanently flat zero often means "not wired up," not "never congested." Treat it as one witness who sometimes doesn't show up to court. A non-zero sustained reading is meaningful evidence of a backed-up send path, but a zero proves nothing by itself. Corroborate saturation the reliable way — throughput pinned near link speed, rising discards, and TCP retransmit behavior on the machines talking through the link.
Errors and discards: the physical evidence
Four counters on the Network Interface object are your damage detectors, and it helps to know they describe two different crimes. Packets Received Errors and Packets Outbound Errors count packets that were damaged or unsendable — corrupted frames, checksum failures, transmit faults. Rising received errors point at the physical world: a failing cable, a dying switch port, a bad transceiver, or a NIC driver having a breakdown. Packets Received Discarded and Packets Outbound Discarded count packets that were perfectly fine but thrown away anyway, usually because buffers were full. That is a resource-pressure story rather than a damage story. It points at driver settings, buffer sizes, or a machine that cannot keep up with its own NIC.
The misread here is dismissal: "it's only a few hundred errors." The healthy value for all four is zero or a number that essentially never grows. Any steady climb is a real, physical finding — and because these counters are lifetime totals since boot, what matters is the growth rate, not the absolute. A thousand errors accumulated over 200 days of uptime is noise; a thousand fresh errors since this morning is a cable you should be replacing this week.
TCP health: retransmits and the ratio that matters
The TCPv4 and TCPv6 objects report the transport layer's own accounting. Because the stack does the retransmitting itself, these numbers are ground truth about what this machine had to send twice. The star pair is Segments Retransmitted/sec and Segments Sent/sec, and they must be read together, because the misread is reading the first one alone. "Twelve retransmits per second" sounds alarming in isolation and means nothing without the denominator. Work the ratio:
Segments Sent/sec = 4,800 Segments Retransmitted/sec = 12 retransmit ratio = 12 / 4,800 = 0.25%
A quarter of one percent: unremarkable. TCP retransmits a little all day on any real network, and a ratio well under 1% is ordinary life. The same 12 retransmits against 300 segments sent would be 4% — a genuinely sick path where users are already complaining. Sustained ratios in the several-percent range mean the machine is spending real time resending, and the slowness is not imaginary. One framing to keep: this ratio reflects loss and delay on the paths this machine actually uses, which is exactly what its users experience. That is a different and complementary measurement from probing the network in general. The packet-loss topic's guide on measuring packet loss covers that side.
Two more TCP counters earn a place, with a reading discipline of their own. Connection Failures counts attempts that never became conversations; Connections Reset counts conversations that ended with a slam rather than a goodbye. Both are cumulative since boot, and the misread is panicking at the lifetime number. For example, 20,000 resets on a server up for half a year is background music, since plenty of ordinary software hangs up rudely. The discipline is to watch the delta: your collector samples the counter on a schedule and alerts on unusual growth. A quiet counter that suddenly gains 500 failures in ten minutes is telling you something just broke — a dead dependency, a firewall change, a service refusing connections. Alongside them, Connections Established is a right-now gauge of open conversations. Its useful trick is having a baseline, so "normally 40, currently 2,000" reads as the leak or the stampede it is.
The supporting cast: UDP, DNS, and DPC time
The UDPv4 object is a smaller ledger because UDP promises less — no retransmission, no connections — but two counters matter. Datagrams Received Errors should sit near zero like the interface error counters. Datagrams No Port/sec counts arrivals addressed to ports nothing is listening on. A steady stream means something is confidently sending this machine traffic it never asked for. That could be a misconfigured client, a stale DNS record pointing old traffic at a new machine, or a scanner taking inventory of you.
You might expect a rich set of DNS client counters to go with this, and honestly, there isn't one worth building on. The deep DNS counter sets live on the DNS server role, not the client. For the client machine's name-resolution experience — which lookups failed, against which server, how slowly — the better instrument is the DNS Client event channel. It is covered in this topic's guide to event logs that reveal network problems.
The last member of the cast is not a network counter at all: \Processor(*)\% DPC Time (with its sibling % Interrupt Time). A DPC — deferred procedure call — is the mechanism the kernel uses to process, among other things, incoming network packets on behalf of the NIC. Here is the pattern that makes it worth collecting. A fast NIC sits in an aging server, throughput plateaus far below link speed, users complain, and overall CPU looks idle. Meanwhile, one core sits pegged servicing DPCs, because packet processing was concentrated on it. The misread is built into the _Total instance: one drowning core averaged across sixteen idle ones rounds down to "fine." Collect per-core, and when a fast link underperforms on a busy server, look here before blaming the network.
Collection discipline
A few habits turn these counters from trivia into monitoring. Sample at sane intervals. Every 15 to 60 seconds is plenty for troubleshooting; every 1 to 5 minutes is right for long-term collection. Sub-second sampling burns CPU to produce noise. Treat counters as trends, not snapshots. Nearly every misread in this guide gets worse when someone reads a single value once; nearly every counter becomes honest when plotted over time. A one-off reading of 3% retransmits might be a blip — a week-long chart that steps from 0.2% to 3% every day at 9 AM is a finding with a schedule.
Baseline per role. "Normal" is not a number; it is a per-machine personality. A file server's byte counters properly roar all day. A domain controller's connection counts swing at login time. A workstation doing any of that is a story. Collect for a couple of ordinary weeks before trusting any threshold, and set thresholds per role rather than fleet-wide. Then wire the counters into your monitoring instead of visiting machines. The counters in this guide are exposed for remote query through WMI — the same catalog, readable across the fleet by a monitoring system or script on a schedule. The next guide in this topic, WMI and CIM for network data, is exactly that playbook. Windows can also answer over SNMP with the standard interface counters, which is handy when a switch-centric monitoring setup already speaks it. The SNMP view covers a fraction of what the native counters offer. So prefer WMI or an agent for Windows depth and keep SNMP for lowest-common-denominator reach. The SNMP topic's guide on enabling SNMP on devices covers that side of the house.
Tip: when a counter's value looks absurd — negative rates, impossible spikes — suspect the measurement before the network. A machine that just rebooted reset every cumulative counter to zero, and a collector that misses samples can turn subtraction math into fiction. Boring explanations first.
The keep-list, on one table
| Counter | Question it answers | Healthy character | Classic misread |
|---|---|---|---|
Network Interface\Bytes Total/sec | How busy is this link? | Well below link speed, with a familiar daily shape | Comparing bytes to a bits-based link speed; forget the ×8 and 96% looks like 12% |
Network Interface\Current Bandwidth | What speed did the link negotiate? | Exactly what you paid for | Assuming it never changes; a gigabit NIC reading 100 Mb has silently downshifted |
Network Interface\Output Queue Length | Is the send path backing up? | Zero to very low | Trusting the zero; many drivers report 0 forever, so silence proves nothing |
Network Interface\Packets Received Errors (and Outbound) | Is the wire damaging packets? | Flat at or near zero | Dismissing a steady climb because the absolute number is small |
Network Interface\Packets Received Discarded (and Outbound) | Are buffers overflowing? | Flat | Confusing discards (resource pressure) with errors (damage) |
TCPv4\Segments Retransmitted/sec | Is this machine resending data? | Under 1% of segments sent | Reading it without Segments Sent/sec; the ratio is the metric |
TCPv4\Connection Failures | Are connection attempts dying? | Slow lifetime growth | Panicking at the since-boot total instead of watching the delta |
TCPv4\Connections Reset | Are conversations being slammed shut? | Steady background growth | Same — cumulative since boot; only the rate of change means anything |
TCPv4\Connections Established | How many conversations right now? | Stable per-role baseline | Judging the number without knowing this machine's normal |
UDPv4\Datagrams No Port/sec | Is unwanted traffic arriving? | Near zero | Ignoring it; a steady stream has a cause worth finding |
Processor(*)\% DPC Time | Is packet processing eating a core? | Low single digits per core | Watching _Total, which averages one drowning core into invisibility |
Where to go next
Twelve counters, each with its misread disarmed — that is a complete, defensible picture of a Windows machine's network health. It is built entirely from instruments the operating system was already running. The natural next step is scale: reading this same keep-list across every server you own, on a schedule, without walking anywhere. That is the WMI guide's job, followed by the event logs that explain why a counter moved. Both are waiting in Windows-Side Network Monitoring, alongside the rest of the host-side toolkit.
Put this into practice with SysPeep Monitor
Everything on this keep-list can be collected by hand with typeperf — or collected for you. SysPeep Monitor gathers Windows performance data over WMI on a schedule. It keeps the history that turns counters into baselines and trends. It alerts when a threshold you chose is crossed, while watching the switches and routers on the same dashboard. The free trial installs on one Windows machine in minutes.
Download Free TrialLearn About SysPeep