Home › Topics › Syslog & Log Collection › Syslog Fundamentals

Syslog Fundamentals: Facilities, Severities, and the Format Zoo


Every network device you own is keeping a diary. The switch in the closet writes an entry when a port goes down. The firewall writes one when an administrator logs in — and a more interesting one when somebody fails to. The UPS writes an entry the moment the building power blinks. The protocol nearly all of them use to narrate their lives is syslog: one of the oldest, simplest, and most universal standards in networking. If a device has a management interface, it can almost certainly speak syslog.


The catch is that the narration arrives as a wall of dense, slightly cryptic text, and nobody hands you a decoder ring. This guide is the decoder ring. By the end you will be able to take apart any syslog message. You will understand the number at the front, the facilities and severities (and where vendors quietly disagree), and the two formats you will meet in the wild. You will know the ways messages travel — and get silently lost. Then we practice on six realistic log lines, because reading logs is a skill you build by reading logs.


In this guide

  • The anatomy of a syslog message
  • The priority number, decoded both ways
  • Facilities: a routing hint, not a taxonomy
  • Severities: the eight-rung ladder
  • The format zoo: classic, structured, and free-for-all
  • Transport: how the diary reaches you
  • Syslog and SNMP traps: two narrators
  • Reading practice: six lines, annotated
  • What to do with each severity

The anatomy of a syslog message


Here is a real-looking syslog message, exactly as it would arrive on the wire at a log collector:


<86>Aug  3 14:07:12 fw-edge-01 sshd[1873]: Failed password for admin from 203.0.113.44 port 51022 ssh2

Reading left to right, there are five parts. First comes the priority: that number in angle brackets, <86>, which encodes two facts about the message in one number (we decode it in the next section). Then a timestamp — month, day, time. Then the hostname of the device that wrote the entry, here fw-edge-01. Then a tag identifying the program or subsystem that spoke, often with a process number in square brackets: sshd[1873]. And finally the message itself — free text, written by whoever wrote the device's firmware, in whatever style they liked that day.


That is genuinely the whole structure. Syslog's greatness and its curse are the same thing: the standard defines a thin envelope and leaves the letter inside almost entirely up to the sender. The envelope — priority, timestamp, hostname, tag — is what this guide teaches you to read fluently; the letter inside is where parsing comes in later.


The priority number, decoded both ways


The angle-bracket number is called the PRI, or priority value, and it packs two smaller numbers into one. One is the facility (a category number saying roughly what kind of source sent this). The other is the severity (how bad it is, from 0 to 7). The recipe is:


priority = facility × 8 + severity

Work it forward once. Suppose a firewall sends a routine VPN status message using facility local0 (facility number 16) at severity informational (severity 6). Then the priority is 16 × 8 = 128, plus 6, giving <134>. That exact number, 134, is one of the most common sights in network logs, precisely because local0-plus-informational is such a popular vendor default.


Now work it backward, which is the direction you actually need when staring at a raw capture. Take the <86> from our example line. Divide by 8 and keep the remainder: 86 ÷ 8 = 10, remainder 6. The quotient is the facility — 10, which is authpriv, the classic Unix category for security and login events. The remainder is the severity — 6, informational. So <86> means "a security-related message of routine importance," which fits a single failed password nicely. Divide by 8, keep the remainder: that one trick decodes every priority you will ever see.


In daily life your collector decodes the PRI for you; you will mostly meet the raw number in packet captures, collector filter rules, and device documentation. But now it is never mysterious again.


Facilities: a routing hint, not a taxonomy


Facilities are the older half of the priority, and their names betray their age. Syslog was born on Unix systems, and the original facility list reads like a tour of a 1980s server room. The ones you will actually meet:


NumberFacilityOriginal meaning
0kernThe operating system kernel itself
3daemonBackground system services
4 / 10auth / authprivLogins, authentication, security events
9cronScheduled jobs
16–23local0–local7"Use these for whatever you like"

Notice that last row. The standard reserved eight facilities — local0 through local7 — with no defined meaning at all, and that is where most network equipment lives. A switch is not a mail server or a line printer, so its vendor simply picks one of the local facilities as a default. Different vendors pick different ones. The switch sends everything there. Some devices also use a few classics: login events on auth or authpriv, service events on daemon. Most let you change the facility in their logging settings.


This leads to the honest rule about facilities: a facility is a routing hint, not a taxonomy you can trust. You cannot assume "auth means login events" across your fleet. One vendor's firmware sends login failures on authpriv. Another's sends them on local4 along with everything else the box has ever felt. What facilities are good for is deliberate sorting that you set up yourself. Suppose you configure all your firewalls to send on local1 and all your switches on local2. Your collector can then route them to different files or apply different rules with one clean test. The facility carries exactly as much meaning as you put into it — no more.


Severities: the eight-rung ladder


The severity is the half of the priority you will care about daily. It is a ladder from 0 (worst) to 7 (chattiest):


  • 0 — Emergency: the system is unusable. In theory, the device's dying gasp.
  • 1 — Alert: act immediately. Something needs a human right now.
  • 2 — Critical: a hard failure — hardware fault, primary function down.
  • 3 — Error: something failed. Not the whole box, but a real failure.
  • 4 — Warning: nothing has failed yet, but something looks likely to.
  • 5 — Notice: normal but significant — a config change, a service restart.
  • 6 — Informational: routine narration. The device describing its ordinary day.
  • 7 — Debug: developer-level detail, meant for troubleshooting sessions, not for production.

Memorize the shape rather than the numbers: 0–2 mean "wake someone," 3–4 mean "look soon," 5–6 mean "for the record," and 7 means "only while investigating." Lower number, louder alarm — which trips up newcomers who expect 7 to be the emergency.


The vendor honesty caveat

Now the part the tidy ladder hides: the severity of any given event is chosen by whoever wrote the firmware, and vendors do not calibrate with each other. The exact same real-world event routinely arrives at different severities from different products:


Real-world eventOne vendor sends it asAnother sends it as
Switch port went downError (3)Warning (4) or Notice (5)
Failed admin loginWarning (4)Informational (6)
Configuration changedNotice (5)Informational (6)
VPN tunnel droppedError (3)Notice (5)

So severity always needs vendor context. Within one product line it is consistent and worth leaning on. Across a mixed fleet, "alert on everything warning-and-worse" pages you for one vendor's routine chatter while sleeping through another's genuine problems. The fix: calibrate per device class — spend a week reading what each product sends at each level. Alert on specific message patterns rather than raw severity alone. The alerting guide in this topic turns that idea into a starter ruleset.


The format zoo: classic, structured, and free-for-all


"Syslog format" is really three layers of reality, and knowing which one you are looking at saves a lot of confusion.


The classic BSD-style format

The example at the top of this guide is the venerable original: priority, then a timestamp like Aug 3 14:07:12, hostname, tag, message. Decades old and gloriously loose. Notice what the timestamp is missing: no year and no time zone. The format assumes the receiver knows what year it is and lives in the same time zone as the sender. These charming assumptions cause real forensic pain, which is why timestamp sanity gets its own guide. Fields are sometimes missing or mangled, single-digit days get a padding space, and plenty of devices bend the rules further. It remains the format most network gear speaks by default, so you will read a great deal of it.


The newer structured standard

A more modern syslog standard tightens all of this up. Its messages carry a version number right after the priority and a full timestamp with year, sub-second precision, and time zone. Then comes the headline feature: optional structured-data blocks. These are bracketed groups of key="value" pairs that machines can parse without guesswork. A message in this style looks like:


<134>1 YYYY-MM-DDT07:58:40.312Z fw-edge-01 ipsec 812 TUNNEL_UP [tun@32473 peer="198.51.100.7" name="branch-office"] IPsec tunnel established

That 1 after the priority is the version field. The square-bracket block is structured data: the peer address and tunnel name as labeled fields rather than prose. When a device offers this format, it is a gift — take it. The catch is adoption: plenty of network equipment either does not offer it or offers it half-heartedly. So a real fleet sends you a mix of both wrappers.


The free-text reality inside

Here is the layer that surprises people: whichever envelope a vendor uses, the message body inside is still free text that the vendor invented. One firewall writes Failed password for admin. Another writes authentication failure: user=admin. A third writes a terse code like %AUTH-4-LOGIN_FAIL. Same event, three dialects — and firmware updates occasionally change the wording. This is the entire reason log parsing exists as a discipline. The envelope tells you who spoke and how urgently, but extracting what they said into searchable fields is its own craft, covered in parsing device logs.


Transport: how the diary reaches you


A syslog message is only useful if it arrives somewhere you can read it, and the delivery options differ in an important way.


UDP on port 514 is the default nearly everywhere: the device fires each message at the collector as a single packet and moves on with its life. No connection, no acknowledgment, no retry. This is wonderfully cheap — a tiny device can do it, and ten thousand messages cost almost nothing. But it is fire-and-forget, and the forgetting is literal. If the packet is dropped by a congested link, a busy collector, or a firewall rule, nothing anywhere records that a log went missing. A dropped log is perfectly silent. For routine narration on a healthy LAN, UDP is honestly fine and is what most devices will use. Just never let a legal or security process assume every UDP log arrived.


TCP, where a device supports it, opens a connection to the collector and gets retransmission and delivery ordering for free. Messages survive brief network hiccups, and the sender can tell when the collector is unreachable. It is the right choice for logs you would genuinely miss — audit trails, security events. There is one honest footnote: TCP improves delivery, it does not guarantee it. During a long collector outage, device-side buffers eventually fill and messages are still lost.


TLS (typically on port 6514) wraps the TCP stream in encryption, so log contents cannot be read or altered in transit. It earns its setup effort whenever logs cross a path you do not fully trust. That includes between sites over the internet, across a shared or third-party network, or in any environment with compliance duties. On a single trusted LAN, most shops reasonably skip it.


Tip: treat log streams as sensitive data, because they are. Auth logs carry usernames and source addresses. Every admin eventually types a password into the username field. At that point, the password appears in a "failed login for user ********" message in glorious cleartext. If logs leave the building, encrypt the path.


Syslog and SNMP traps: two narrators


If you have explored SNMP, you know devices have a second way to announce events: the trap, an unsolicited SNMP message sent when something happens. Traps and syslog are siblings — both are push-on-event channels — but their characters differ. A trap is a structured ping: a numeric identifier plus a few typed variables, terse and machine-friendly, ideal for tripping automation. A syslog message is prose: richer, more contextual, human-first, and in need of parsing before machines enjoy it. Many devices can send both, and enabling both costs little. When a port drops, the trap trips your monitoring while the log line tells the fuller story. The pair also shares one blind spot: a device that dies instantly sends neither — which is why event channels complement, and never replace, active polling. The trade-offs are mapped out in traps versus polling.


Reading practice: six lines, annotated


Time to build the skill: six realistic messages, from six device types, of the kind a small network produces every week. For each: decode the envelope, then read the story.


1. A failed login, at a bad hour

<86>Aug  3 02:11:47 fw-edge-01 sshd[20415]: Failed password for root from 198.51.100.23 port 44012 ssh2

Priority 86 = facility 10 (authpriv), severity 6 (informational). One failed root login from an internet address at 2 AM is background radiation on any exposed device. A burst of five hundred is a password-guessing run. This is the classic case where a single line means nothing and the count means everything — you do not read these, you count them.


2. A link flap

<187>Aug  3 09:41:55 sw-core-01 512: %LINK-3-UPDOWN: Interface GigabitEthernet1/0/24, changed state to down

Priority 187 = facility 23 (local7), severity 3 (error). The message body uses the mnemonic style many network vendors favor: subsystem, severity digit, event name. Note the 3 inside %LINK-3-UPDOWN matches the envelope severity. The 512 is the device's own message sequence number, handy for spotting gaps. One down followed by an up seconds later is a flap. The same port flapping dozens of times a day is a failing cable, patch panel, or transceiver telling you exactly where to look.


3. A configuration change

<189>Aug  3 16:22:03 sw-core-01 519: %SYS-5-CONFIG_I: Configured from console by jsmith on vty0 (10.20.0.15)

Priority 189 = local7, severity 5 (notice) — "normal but significant" fits perfectly. This line answers the three questions every outage postmortem begins with: who (jsmith), from where (10.20.0.15), and when (16:22, shortly before things got weird, as tradition demands). Config-change messages are among the most valuable lines your network produces; when something breaks, the first search is always "what changed."


4. A VPN tunnel comes up

<134>Aug  3 07:58:40 fw-edge-01 ipsec: IPsec SA established: tunnel to 198.51.100.7 (branch-office) up

Priority 134 = local0, informational — our worked example from earlier, in the wild. The subtlety: a tunnel coming up at 07:58 implies it was down before. Recovery messages are often logged more cheerfully (and at milder severity) than the failure that preceded them. So when you see one, scroll back and find its darker twin. The pair brackets the outage window for you.


5. A DHCP conflict brewing

<28>Aug  3 11:15:26 dhcp-01 dhcpd: Abandoning IP address 10.20.30.77: pinged before offer

Priority 28 = facility 3 (daemon), severity 4 (warning). Translation: the DHCP server was about to hand out .77, checked first, and something already answered from that address. That is usually a device someone configured with a static address inside the dynamic pool. Today it is one abandoned address; left alone, it becomes intermittent "IP address conflict" chaos. This is syslog at its best: a slow-burn problem announcing itself weeks before users notice.


6. A power event

<129>Aug  3 18:40:09 ups-rack1 upsmon[644]: UPS ups@localhost on battery

Priority 129 = local0, severity 1 (alert) — and the vendor is right to shout. The building has lost utility power and the rack is running on a battery with minutes of runtime. A grim practical note: if the outage takes down your switches, the UPS's next messages may never reach the collector. In that case, over UDP, "on battery" might be the last thing you hear. Exactly why power events belong in the page-immediately category.


What to do with each severity


Reading messages one at a time is a skill; handling thousands a day requires defaults. Here is a sensible starting policy for a small network — remembering the vendor caveat, so treat it as a first draft to tune per device class:


SeverityNameSensible default handling
0EmergencyPage a human immediately (rare in practice; verify the sender is not crying wolf)
1AlertPage a human immediately
2CriticalNotify right away, working hours or not
3ErrorTicket or notification for same-day review
4WarningStore; review in a scheduled daily or weekly sweep
5NoticeStore; alert only on specific patterns (config changes, logins on infrastructure)
6InformationalStore only — this is the searchable history that pays off later
7DebugDo not send to the collector at all, except during an active investigation

Two refinements make this table work. First, "store" is doing quiet heroic work: the informational messages you never alert on are what reconstructs an incident afterward. Second, the best alerting is pattern-based, not severity-based — a burst of severity-6 login failures matters more than one severity-3 error from a chatty appliance. Building those patterns is the subject of alerting on logs.


Where to go next


You can now look at a raw syslog message and read every part of it. You understand the priority arithmetic, the facility's limited honest meaning, the severity with appropriate vendor skepticism, and the story in the body. The natural next step is to give all that narration somewhere to go. Build a central syslog server in an afternoon for free. Follow it with a deliberate policy on what to collect and what to drop. The full set of guides lives in Syslog & Log Collection.


Put this into practice with SysPeep Monitor

Logs tell you what happened; you still need something watching whether devices are healthy right now. SysPeep Monitor auto-discovers your network and polls device health, port status, and performance over SNMP, WMI, and SSH. Its thresholds and alert rules are built to keep the noise down. It pairs naturally with the log-reading skills you just built, and the free trial installs on any Windows machine.

Download Free TrialLearn About SysPeep