What's Actually in a Firewall Log (and What Isn't)
Your firewall makes thousands of decisions a minute and writes most of them down. That transcript is the firewall log, and sooner or later somebody will say to you, "just check the firewall logs." You will open them and find a wall of text in which every line looks exactly like every other line. You will quietly wonder how anyone gets answers out of this.
The trick is that every line has the same shape. If you can read one line — really read it, field by field — you can read a million. A million lines are the same dozen fields repeated. This guide teaches you that one line. By the end you will know what each field means and which questions a firewall log can answer. Just as importantly, you will know which questions it cannot answer no matter how hard you stare.
In this guide
- One line, dissected
- The core fields, one at a time
- Session logs: start, end, bytes, and duration
- Identity fields: user and application
- The allow-versus-deny logging decision
- The volume reality and what it does to you
- What a firewall log can never tell you
- The honest reading list: fields and the questions they answer
- Where to go next
One line, dissected
Every firewall vendor formats logs differently: key=value pairs, comma-separated columns, or structured records that a log platform unpacks for you. Underneath the formatting they all record the same handful of facts. They all answer the same question: a packet arrived, and what did I do with it? Here is an illustrative deny line in a generic key-value style; your firewall will use different names for the same things.
Mar 14 09:22:31 fw-edge-01 action=deny in=wan out=- proto=tcp src=203.0.113.45 spt=51234 dst=198.51.100.10 dpt=3389 rule=deny-all-inbound
Read it left to right, like a sentence:
- Mar 14 09:22:31 — when the firewall made the decision.
- fw-edge-01 — which firewall is talking; essential once several devices log to one place.
- action=deny — the verdict. The packet was refused.
- in=wan out=- — it arrived on the internet-facing interface and never left through any interface, because it was denied.
- proto=tcp — the transport protocol.
- src=203.0.113.45 spt=51234 — who sent it (source address) and from which port.
- dst=198.51.100.10 dpt=3389 — where it was going, and which service it wanted. Port 3389 is the standard port for Remote Desktop.
- rule=deny-all-inbound — the policy line that made the decision.
In English: "At 9:22 this morning, somebody on the internet tried to open a Remote Desktop connection to one of our public addresses, and the catch-all inbound deny rule refused them." That is a complete, useful sentence, and every field contributed a word. Now an allow line, which carries more fields because the session actually happened:
Mar 14 09:23:05 fw-edge-01 action=allow type=session-end in=lan out=wan proto=tcp src=10.20.4.17 spt=49822 dst=203.0.113.80 dpt=443 rule=lan-to-internet-web user=jsmith app=web-browsing bytes_sent=8412 bytes_recv=1206338 duration=42
"A session from an internal workstation to a web server on the internet, permitted by the rule that lets the office browse the web, just ended after 42 seconds. It sent about 8 kilobytes and received about 1.2 megabytes. The firewall believes the user was jsmith and the application was ordinary web browsing." Notice the new fields — a session type, a user, an application, byte counts, a duration. We will take each in turn.
The core fields, one at a time
Timestamp
The timestamp records when the firewall wrote the line, which is usually (but not always) when it made the decision. Two things bite beginners. First, clock accuracy: a firewall whose clock drifts produces logs that disagree with every other device, and "which happened first?" becomes unanswerable. Every device should sync its clock with NTP (Network Time Protocol), the standard way computers agree on the time. Second, time zones: some firewalls stamp local time, some stamp UTC, and a central collector may add its own receive-time on top. Know which zone each source uses before you compare them. A log with the wrong clock is a confident witness telling the wrong story.
Action
The action is the firewall's verdict. You will see allow (sometimes permit or accept) for traffic that passed. Refused traffic comes in two flavors. A drop means the packet was silently discarded and the sender heard nothing. A reject (or reset for TCP) means the firewall sent a polite "no" back. Both are denies for analysis purposes, but the difference matters when someone complains that a connection "hangs" (drop) versus "fails instantly" (reject). Session-aware firewalls add verbs like close, timeout, or end for the record written when a permitted session finishes. Learn your firewall's vocabulary once; the words vary, the concepts do not.
Source and destination address and port
The source is whoever started the conversation; the destination is whoever they wanted to reach. Direction matters enormously: an internal host denied on its way to the internet means something completely different from an internet host denied on the way in. Ports tell you which service was involved. The destination port is the interesting one: 443 means the web over TLS, 25 means mail, 3389 means Remote Desktop, 22 means SSH. The source port is almost always a random high number the client picked for that one conversation (an ephemeral port). It is useful mainly for matching the two ends of one session across different logs.
One trap: NAT (Network Address Translation), the feature that rewrites private internal addresses to your public address on the way out. The log may show the address before translation, after it, or both in separate fields. Suppose you are chasing "which internal machine made this connection?" and the log shows only your public address. You are looking at the post-NAT field and need the pre-NAT one.
Protocol
Usually tcp, udp, or icmp. TCP and UDP carry ports; ICMP (the protocol behind ping and network error messages) has no ports and instead reports a type and code. Some firewalls log the protocol as a number — 6 is TCP, 17 is UDP, 1 is ICMP. That is worth memorizing because it is exactly the kind of thing that stops a search dead late at night.
The rule that matched
This field turns a firewall log from a record of traffic into a record of policy. Every decision was made by one specific rule — a numbered or named line in your rulebase — and the log tells you which. So you can ask "what is my 'temporary vendor access' rule actually carrying?" and "did anything hit the rule that should never fire?" Watch for the catch-all: most firewalls have an implicit deny at the bottom of the rulebase that refuses whatever nothing else matched. It often logs under a special name (default-deny, implicit-drop, or rule number zero). On some products it does not log at all until you switch it on. If you enable logging on only one rule, make it that one.
Interface and zone
Interfaces are the physical or virtual ports the packet came in on and went out of. Zones are the friendly names you give groups of interfaces — wan, lan, dmz, vpn, guest. Together they show direction at a glance; a denied packet has an inbound interface and no outbound one, because it went nowhere. The zone pair is often the fastest way to sort log lines. The piles are "internet noise," "guest network doing guest things," and "something inside talking to something else inside." That last pile is worth reading first.
Session logs: start, end, bytes, and duration
Modern firewalls are stateful. Rather than judging every packet in isolation, they recognize the first packet of a new conversation and decide once. They remember the session so the following packets flow without re-evaluation. That design shapes the log. Instead of one line per packet (absurd), a stateful firewall writes a line per session — at the beginning, at the end, or both.
- Session-start records are written the moment a session is permitted. They carry addresses, ports, protocol, and rule, but no byte counts or duration, because nothing has happened yet. Their timestamp is exactly when the conversation began.
- Session-end records are written when the session closes — normally, by a reset, or by timeout after silence. They carry everything the start record had, plus bytes sent and received, often packet counts, the duration, and sometimes a close reason. Their timestamp is when the session ended.
Three consequences follow, and each trips up new analysts. First, when you want to know how much data went somewhere, count end records only; start records carry no byte counts. Second, a long session distorts your timeline. A four-hour download that ends at 07:02 appears in the end log at 07:02, but it started at 03:02. Subtract the duration when you reconstruct "what was happening at 3 AM." Third, UDP has no real sessions. The firewall invents them by grouping packets between the same addresses and ports and closing the group after a quiet period. So a UDP "session" of many minutes may be a stream or many unrelated packets that looked alike.
Tip: Most firewalls let you choose, per rule, whether to log at session start, session end, or both; both doubles the lines. A common compromise is end-only on high-volume allow rules (you still get bytes and duration). The other half is start-plus-end on rules to sensitive zones. There, the precise moment a connection opened is worth the extra line.
Identity fields: user and application
Beyond addresses and ports, many firewalls attach richer labels to a session. A user field appears when the firewall knows which person is behind an address. Typically, it knows through directory integration or because the session came in over a VPN the user authenticated to. An application field appears when the firewall inspects traffic deeply enough to recognize what it is carrying, rather than just noting the port. Examples are a web browser, a file-sync client, or a video call. Some add a URL category, a threat name when an inspection engine fired, a country for the remote address, and more.
These fields are wonderful when present and dangerous when trusted blindly. Application identification is a best guess from traffic patterns, sometimes wrong, especially early in a session. User-to-address mapping goes stale. A shared workstation, a user who logged off, or a device with no directory login can all produce a confident-looking user= value. That value can be simply outdated. And identity fields only exist when the feature is enabled and, on many products, licensed. Read them as the firewall's opinion, and verify against the directory or the endpoint before you act on a name.
The allow-versus-deny logging decision
Every rule has a logging switch, and the most consequential choice in firewall logging is which switches you flip. The two kinds of records have opposite personalities.
Denies are cheap and interesting. A deny is one line per refused attempt, with no session to track and no bytes to count. Each line records something that wanted to happen and did not. It might be a probe from the internet or an internal machine reaching for a port it has no business reaching. Or it might be a rule doing its job. Deny logs are small relative to the traffic they describe, and they are where most surprising findings live. There is very little reason not to log every deny on every internet-facing and inter-zone rule.
Allows are voluminous but reveal what actually happened. An allow line is written for every permitted conversation, and permitted conversations are the overwhelming majority of what a firewall handles. Logging them costs storage and collector bandwidth. But something might go wrong — a compromised workstation, a "who talked to that address?" from an investigator. In that case, the allow log is the only place the answer exists. Denies tell you what was refused. Allows tell you what happened. A sensible starting policy is to log all denies everywhere. Log allows on rules that touch sensitive zones or cross trust boundaries. Sample or summarize allows on bulk internal-to-internet rules once you understand your volume. The sibling guide on what to keep, review, and ignore turns that starting policy into retention tiers.
The volume reality and what it does to you
A busy internet edge writes an enormous number of lines, because logging scales with traffic rather than with problems. And the internet contributes a constant background of probes to anything with a public address. The consequences follow. Disk fills faster than expected. The link to your log collector carries a steady stream. Searches that were instant on a week of data crawl on a month. And — the one that actually changes your behavior — no human can read it. The volume forces you to work by aggregation: counting, grouping, ranking, and reading summaries instead of lines. Every other guide in this pillar is really a guide to aggregation. Which handful of firewall events deserve a real-time alert is a separate question. It is covered in firewall logs and alerts. This pillar is the retrospective side, where you sit down with the transcript and read it on purpose.
What a firewall log can never tell you
Now the honest part. A firewall log is a record of decisions the firewall made about headers it saw. That sentence has limits baked into it, and knowing them will save you from confident wrong conclusions.
- No payload. The log records who talked to whom, on which port, for how long. It does not record what they said. Even if the firewall inspected content to identify the application, it did not write the content down, and most of it was encrypted anyway. "The log shows they downloaded a file" is a stretch; what it shows is a session with many bytes received.
- No intent. A deny from an internet scanner and a deny from a misconfigured partner system look identical: an address, a port, a refusal. The log tells you what was attempted, never why. Intent comes from context — patterns over time, what else the source did, what the destination is — which is the work of analysis.
- No verdict on allowed traffic.
action=allowmeans "this matched a rule that says allow." It does not mean the session was benign. Malware talking to its controller over port 443 produces a perfectly ordinary allow line under your web-browsing rule. The allow log lists things that were permitted, not things that were safe. - Nothing after the firewall. What the destination host did with the connection, whether a login succeeded, what file was written — none of that is here. It lives in the server's, endpoint's, and application's logs.
- Nothing that bypassed it. Two workstations on the same subnet talk to each other without the firewall ever seeing a packet. Internal east-west traffic is invisible to an edge firewall unless your network is segmented so that it must cross one. A log with no entry is not proof nothing happened; it is proof the firewall was not in the path.
- Nothing on a rule with logging off. The most common cause of "the log shows nothing" is that the matching rule was never configured to log. Before concluding traffic did not occur, confirm the rule that would have handled it logs at all.
And a quieter limit: the firewall reports what it believes. A stale user mapping or an application guessed from an early packet is an honest report of its best understanding at the time. A good analyst holds such fields a little loosely.
The honest reading list: fields and the questions they answer
Here is the whole guide as a lookup table. When you have a question, find the row that answers it. When you have a field, find the row that says what it is good for and where it misleads.
| Field | Question it answers | Where it misleads |
|---|---|---|
| Timestamp | When did this happen, and in what order? | Unsynced clocks; local time versus UTC; end records are stamped at close, not open |
| Action | Was it permitted or refused? | Drop and reject are both denies; "close" and "timeout" describe how a session ended |
| Source address | Who started the conversation? | NAT or a proxy can hide the real initiator; pre- and post-translation fields differ |
| Source port | Which end of a session is this? | Ephemeral and random; rarely meaningful on its own |
| Destination address | What was the target? | Inbound NAT may show the public address rather than the internal server |
| Destination port | Which service was wanted? | Services can run on non-standard ports; 443 carries far more than web pages |
| Protocol | TCP, UDP, or ICMP? | Sometimes logged as a number; ICMP has type and code instead of ports |
| Rule | Which policy line made the call? | The implicit deny may not log by default; rule renumbering after edits breaks old searches |
| Interface / zone | Which direction was it traveling? | Zone names are yours to define; be consistent across firewalls |
| Bytes / packets | How much data moved, each way? | Only on end records; direction naming (sent versus received) varies by vendor |
| Duration | How long did the session last? | UDP durations are timeout artifacts; subtract from the end time to find the start |
| User | Which person was behind the address? | Stale mappings, shared machines, unauthenticated devices |
| Application | What kind of traffic was it, beyond the port? | A heuristic guess; may change mid-session; requires the feature to be on |
Two habits complete the skill. Build a one-page cheat sheet mapping your firewall's field names to the rows above. And when a "check the logs" request arrives, translate it into fields before you search. "Did the accounting server talk to anything outside?" becomes "allow records, source equals that server, outbound zone is wan, grouped by destination." The question comes in English; the answer comes out of fields.
Where to go next
You can now read a firewall log line like a sentence. It tells you who, to whom, wanting what, decided by which rule, in which direction, and when. For permitted sessions, it also tells you how much and for how long. You also know the walls: no payload, no intent, no guarantee that "allowed" meant "fine." That honesty separates analysis from guessing.
The rest of the Firewall Log Analysis Fundamentals guides build on these fields. The next one decides what to keep, review, and ignore. Then deny-log mining turns the cheap, interesting deny records into intelligence. The guide to closing the loop uses the rule field to improve your rulebase. And the tooling guide shows a small team how to do it all without a large budget.
Put this into practice with SysPeep Monitor
Firewall logs tell you what the firewall decided; they say nothing about whether the firewall itself is coping. SysPeep Monitor watches the box that writes all those lines — CPU, memory, session counts, and interface throughput over SNMP. It alerts you when the device is struggling. That way, the transcript you are learning to read never goes quiet without warning. The free trial installs on any Windows machine.
Download Free TrialLearn About SysPeep