Skip to content

LUnA v2.0.0

Latest

Choose a tag to compare

@logiqum logiqum released this 26 Oct 18:17
· 7 commits to main since this release
af69236

Download: logrok.com/download — installers for every platform, checksums and install commands.

Upgrading to 2.0.0

2.0.0 is a major version because the service has a new name on Linux, macOS and FreeBSD (it is now
logrok-universal-agent everywhere, as it already was on Windows), and because the Apex modules that
1.x only warned about are now enforced. Every configuration that 1.x accepts is
accepted unchanged, with one exception: a misspelt option name on the filetail, linux_audit, etw or
windows_eventlog input, which 1.x ignored.

  • Unlicensed agents that use etw, wmi, linux_audit, mqtt_in, redact, lookup,
    adaptive_sample or a destination other than syslog:
    1.x warned that these Apex modules would be
    disabled in the next major version. 2.0.0 disables them: without a covering license the agent removes
    them at start and keeps running everything else, so events stop reaching such a destination. Before
    upgrading, install a license or enroll with a logrok control plane (an enrolled agent receives its
    entitlement from it), or move the pipeline to Core modules. The startup log names every module it removed.

  • Before a remote upgrade: run logrok-universal-agent -check-config with the 1.x agent's configuration
    and correct any option it names as unknown. The upgrade check 2.0.0 runs before it installs refuses such a
    key, so the agent stays on its current version until the key is fixed.

  • Installed folders and the service user now use the product name. The package upgrade moves them, with
    the agent stopped, and leaves nothing of the old names behind: no folder, no link, no old user. The enrolled
    identity and any undelivered events move with the state folder; nothing is copied or re-created, so the
    agent does not enroll again.

    • Your local agent.yaml is updated to match. Every path under an old folder becomes the same path under
      the new one (for example a spool folder or a CA file); each changed line is shown in the install output.
      The new agent must accept the changed file before the upgrade goes on. If it does not, the file is left
      exactly as it was, the upgrade stops with the reason, and the agent is not started: correct the file and
      finish the upgrade again.
    • Configurations delivered from a control plane are not changed on the host. Update any that name an
      old path in the control plane before upgrading the package, and change scripts or other tools of yours that name
      an old path.
    • A state folder that is a mount point of its own stops the upgrade before anything is changed, because
      moving it would mean copying it. The message says how to mount the volume at the new path; do that, then
      upgrade again.
    • Linux: /etc/logrok-agent → /etc/logrok-universal-agent, /var/lib/logrok-agent →
      /var/lib/logrok-universal-agent, /var/log/logrok-agent → /var/log/logrok-universal-agent (when you
      created it for log_file), and the user logrok-agent is renamed logrok-universal-agent with
      the same UID and GID.
    • macOS: /usr/local/etc/logrok-agent → /usr/local/etc/logrok-universal-agent,
      /usr/local/var/db/logrok-agent → /usr/local/var/db/logrok-universal-agent, and the log files are now
      /usr/local/var/log/logrok-universal-agent.out.log and .err.log.
    • FreeBSD: /usr/local/etc/logrok-agent → /usr/local/etc/logrok-universal-agent, /var/db/logrok-agent
      → /var/db/logrok-universal-agent, /var/log/logrok-agent.log → /var/log/logrok-universal-agent.log,
      moved on the first start of the new service, which also updates the configuration as above. A path you
      set yourself in rc.conf stays where it is. If the move or the check cannot be done, the service does not
      start and says why.
    • Windows: unchanged (C:\ProgramData\logrok-universal-agent).
    • Containers: the image now reads /etc/logrok-universal-agent/agent.yaml and keeps its state in
      /var/lib/logrok-universal-agent. If you run the image yourself, mount your config file and your existing
      volume at these paths; the volume's contents carry over unchanged. With the Helm chart, the collector's
      folder on each node is /var/lib/logrok-universal-agent.
  • Linux (deb, rpm): nothing to do. Upgrading the package moves an enabled or running agent to
    logrok-universal-agent.service, and logrok-agent stays an alias, so existing systemctl commands and
    scripts keep working. An agent.yaml you edited stays your configuration without a prompt, and the new
    default is put beside it as agent.yaml.dpkg-dist (rpm: agent.yaml.rpmnew); one you never edited is
    replaced by the new default. If the upgrade stopped on the configuration check, correct agent.yaml and
    finish it with dpkg --configure -a (rpm: reinstall the package).

  • macOS (.pkg): nothing to do. The installer unloads and removes the old com.logiqum.logrok-agent
    LaunchDaemon and starts com.logiqum.logrok-universal-agent. Scripts that call launchctl with the old
    label need the new one. An agent.yaml still exactly as an earlier package installed it is replaced with
    the new macOS default (the old file is kept as agent.yaml.pre-2.0); a file you edited is never changed.
    From 2.0.0 on, an agent.yaml you have not edited is updated with each package, as on Linux and Windows.
    The folders move to their new names as described above.

  • FreeBSD (rc.d): replace the rc script: service logrok_agent stop, remove
    /usr/local/etc/rc.d/logrok_agent, install the new script and start logrok_universal_agent. Your
    logrok_agent_* settings in rc.conf keep working while the new names are unset. The new service refuses to
    start while the old script is installed, so two agents never run on one spool. If newsyslog.conf rotates
    /var/log/logrok-agent.log, change it to the new file name.

  • Windows: nothing changes; the service was already logrok-universal-agent.

  • Agents upgraded remotely from the control plane get the new binary and keep their current service name
    until their package is upgraded.

  • No 32-bit ARM rpm. The armv7hl rpm packages are no longer published. On 32-bit ARM, use the armhf .deb or the luna-linux-armv7 binary; the binary is the same as before.

Added

  • UDP syslog and GELF on several cores, and UDP loss you can see. syslog_in and gelf_in can read one UDP port on several cores (udp_listeners, a number or auto, Linux and FreeBSD). A high-rate UDP feed, even from one busy sender such as a relay or a firewall, can then use more than one core, with no extra privileges needed. Message order across listeners is not kept; the default of 1 keeps today's behaviour. udp_receive_buffer_bytes sets the UDP socket receive buffer, and on Linux the datagrams the operating system dropped because they were not read in time are counted in logrok_agent_input_udp_kernel_drops_total.
  • Several batches on the way to Splunk at once (max_in_flight). The hec output can now keep up to 64 batches on the way at once instead of waiting for each answer before sending the next — for a distant or slow Splunk receiver, where the round trip, not the agent, limits throughput. In our test with a receiver on the same host, four batches in flight more than doubled the HEC throughput (about 280,000 to 610,000 events per second on 10 cores). Off by default (1, unchanged behaviour). Splunk may then receive batches out of order; inputs still advance strictly in read order, a failed batch is spooled before anything after it is acknowledged, and delivery stays at-least-once. Other outputs do not accept the key: -check-config refuses it there. Older agents do not know it either.
  • Warning up front when read positions cannot be saved. If an input saves its read position by default and the folder it would use is not writable by the agent, -check-config and the agent's startup now say so once, with what to change (management.state_path, the STATE_DIRECTORY setting, or the input's own position option) — instead of the problem showing only as warnings after the agent is running. The check creates nothing. On Windows it cannot tell, so it stays silent there.
  • Pipeline stage metrics. With service.workers above 1, /metrics shows where time is spent in the pipeline — so you can see whether more workers would help or whether sending is the limit.
  • Longer, configurable stop grace (service.shutdown_grace). When the agent stops it now keeps delivering its last batch for up to 15 seconds (it used to be 2) before giving up; set shutdown_grace under service: (1 second to 10 minutes) to change it. A batch not delivered in time is read again after the restart by file, journal and event-log inputs; network inputs that cannot be replayed lose it. An agent of an earlier release does not know the key: it starts and keeps its shorter stop grace, and its -check-config reports shutdown_grace as unknown.
  • Processors on several cores (service.workers). Set workers under service: to 2 or more and the agent processes events across that many cores. Processors that must see events in arrival order — dedup, throttle, quota, unkeyed sample, adaptive_sample and aggregate — keep running in order, so place the others first. Events reach each destination in the same order and batches as before, and inputs still save their position only after their events are delivered or durably spooled; the agent logs the arrangement and warns when nothing can run in parallel. The default stays 1, the pipeline of earlier releases unchanged. An agent of an earlier release does not know the key: it starts and processes as before, and its -check-config reports workers as unknown.
  • LUnA (Logrok Universal Agent) Crescent — a smaller edition for constrained hosts. Each release now also ships LUnA Crescent, a reduced-footprint build of the same static agent for OT gateways, appliances and single-board computers. It keeps the core inputs and the syslog output and disk store-and-forward, and leaves out the heavier integrations (Kafka, S3/Parquet, OTLP, Elasticsearch, Loki, Microsoft Sentinel, Cortex XSIAM, Splunk HEC, Beats, Fluent, MQTT, SNMP traps, Modbus and the OpenWEC input). A configuration that names a module Crescent does not include is refused at -check-config with a clear "not included in this build" message. Downloads are named luna-crescent-<os>-<arch> for Linux (amd64, arm64, armv7, riscv64, mipsle), FreeBSD (amd64, arm64), OpenBSD and NetBSD (amd64), plus Linux tar.gz archives and logrok-universal-agent-crescent deb/rpm packages, which replace the full package when installed (same installed paths).
  • Every event says it came from LUnA. Each event the agent collects now carries agent_type (luna), agent_version, and agent_id once the agent is enrolled. In logrok they appear as extra.agent_type, extra.agent_version and extra.agent_id, so one filter (extra.agent_type:luna) shows LUnA events apart from NXLog, Winlogbeat or any other sender, grouped or not. Events a gateway agent receives from other collectors (syslog, OTLP, Beats, Fluent, HEC, GELF, HTTP, OpenWEC) are not labeled LUnA, and events an edge agent stamped keep the edge agent's identity. A Windows event cannot set these fields through its event data.
  • Windows hosts without an agent. The new openwec_in input receives the events Windows hosts send with the built-in Windows Event Forwarding, through an OpenWEC collector — no agent installed on those hosts. Events arrive with the same fields as from the agent on the host, plus which machine delivered them, and an event whose claimed host is not the machine that sent it is marked, or dropped if you choose. Checked with a Windows 11 host forwarding over TLS with a client certificate. Apex.
  • More Windows event fields, including who the event is about. Windows Event Log events now also carry the event version, the task and opcode (number and name), the keywords (value and names, such as Audit Success), the provider GUID, the activity IDs that group the events of one operation, and the user SID. The SID is resolved on the collecting host to account_name, account_domain and account_type, matching the fields NXLog provides. Set resolve_sids: false where a lookup would wait on an unreachable domain controller. Existing event fields keep their names.
  • -self-check says what your licence switches off. Its JSON verdict now lists, under warnings, every module the licence removes (for example a second destination on an unlicensed agent), plus the configuration warnings -check-config gives. Before, the startup log was the only place this showed.
  • Program name from RFC 3164 messages. parse_tag: true on the syslog_in input takes the tag of an RFC 3164 message (myapp[88]: text) out of the message text and sends it on as APP-NAME and PROCID. Text that only resembles a tag — a URL, a phrase with a colon — is left as it was. Off by default, so message content does not change unless you turn it on.
  • Warning for newline framing to syslog-ng syslog() receivers. syslog-ng syslog() sources, including appliance RFC 5424 ports, expect octet-counting framing and silently drop newline-framed messages. The agent now warns at startup, and -check-config lists a warning, when a syslog or snare destination's port is 601 or 6587 with framing: newline.
  • Warning for client certificates a strict receiver refuses. When a client certificate you configured for a TLS syslog or Snare destination is restricted to other uses (for example server authentication only), the agent warns at startup and -check-config lists it under warnings. Receivers that check key usage — including logrok's agent listener — refuse such certificates; reissue it with client authentication.
  • luna-migrate — move from another forwarder in one command. A separate small tool, published with every release beside the agent (the agent binary itself carries no converter), that turns another forwarder's configuration into an agent configuration plus a report of everything it could not carry over, and validates the result with the installed agent. Sources: Splunk Universal Forwarder, Filebeat, Winlogbeat, NXLog, Fluent Bit, Promtail, the OpenTelemetry Collector, Graylog Sidecar, Elastic Agent, Wazuh / OSSEC, Datadog Agent, Azure Monitor Agent, Fluentd, Logstash, rsyslog, Vector and syslog-ng (details below). Credentials are never copied.
  • luna-migrate options for every source. -syslog-plain sends to the syslog receiver over plain TCP instead of TLS; -windows / -linux choose the target platform when the source configuration does not say; for Wazuh, -agent-conf, -os, -profile and -agent-name choose which shared agent.conf blocks apply. An option that does not fit the chosen source is refused instead of ignored.
  • luna-migrate -finding-summary — tell us what your configuration used, without telling us anything else. Writes a small JSON file with only the names of the settings the conversion could not carry over and how often each occurred (plus the tool and source versions and the number of inputs and destinations per type). No values, paths, host names, addresses, secrets or names you chose; a name that does not look like a product's own setting name is only counted. You read the file and decide whether to send it — the tool sends nothing.
  • luna-migrate says what each converter was checked against. Its summary, its JSON report (verified_against) and each migration guide name the versions of the source tool the converter was verified with, and what was run end to end. For syslog-ng configurations the report also records the file's own @version and notes when it is newer than the verified 4.12.
  • Migrate from syslog-ng. luna-migrate syslog-ng converts a syslog-ng OSE configuration with its @include files: file, journal, socket and network sources; log-path routing with filters and final/fallback paths; JSON/key-value/CSV/XML parsers and simple rewrites; syslog, Elasticsearch, Kafka, Loki and Splunk HEC destinations. Templates, pattern databases and the rest are listed in the report. Verified end to end: syslog-ng itself and the converted agent, given the same traffic, delivered exactly the same messages.
  • Migrate from Vector. luna-migrate vector converts a Vector configuration (YAML, TOML or JSON, including configuration directories): files, the journal, syslog and sockets, the Windows event log, HTTP and Splunk HEC receivers and Kubernetes pod logs, delivered to Loki, Splunk, Elasticsearch, Kafka, S3 or syslog. Filters and routes that apply to only some destinations stay limited to those destinations; VRL that cannot be converted is listed with its file and line. Verified end to end: Vector and the converted agent delivered the same entries with the same labels into a real Loki.
  • Migrate from rsyslog. luna-migrate rsyslog converts an rsyslog configuration — RainerScript, legacy $ directives and selector lines, with its includes. File inputs keep their tag, facility and severity; network listeners, the journal, TLS forwarding and Elasticsearch and Kafka destinations convert; rsyslog's filters, rulesets and stops decide exactly what each destination receives. Anything that cannot be converted is listed in the report with its line. For a relay host, keeping rsyslog and pointing it at the agent's syslog input is often the simpler move. Verified end to end into a real rsyslog receiver, with the source configuration accepted by rsyslog itself.
  • Migrate from Logstash. luna-migrate logstash converts Logstash pipelines (a .conf file, a conf.d directory or pipelines.yml): file, Beats, syslog, TCP/UDP and HTTP inputs, if/else conditionals, drop and mutate filters, json/kv/csv parsing, and Elasticsearch, Kafka, syslog and S3 outputs with their routing kept. grok, date, ruby and the rest are listed in the report with what to do instead. Where Logstash is a central tier, the agent's Beats receiver in front of it is often the simpler move. Verified end to end into a real Logstash, with the source pipeline accepted by Logstash itself.
  • Migrate from Fluentd, td-agent or fluent-package. luna-migrate fluentd converts the configuration with its @include files and keeps Fluentd's tag routing — first match wins, labels, relabel and copy: file, syslog, Forward, HTTP, journal and Windows Event Log sources; grep, record_transformer and JSON parser filters; Forward, Elasticsearch, Kafka, S3, Loki, Splunk HEC and syslog destinations. Embedded Ruby is never evaluated and credentials are never copied. Verified end to end into a real Fluentd receiver, with the source configuration accepted by Fluentd itself.
  • Migrate from the Azure Monitor Agent. luna-migrate azure-dcr converts a data collection rule (portal JSON view, REST export or ARM template): Windows event queries, syslog facility/level selections, text and JSON logs with multi-line records, IIS and Windows Firewall logs and ETW providers, delivered to Microsoft Sentinel / Log Analytics through the Logs Ingestion API or to any syslog receiver. KQL transformations and other steps that need a person are listed in the report. Verified end to end through a real rsyslog into a real syslog receiver; delivery into Log Analytics was not part of the test.
  • Migrate the log collection of a Datadog Agent. luna-migrate datadog converts datadog.yaml and the conf.d log sources — files, TCP/UDP, journald and Windows Event Log, with exclude/include, masking and multi-line rules — into an agent configuration that sends the same logs, with their service, source and tags, to any syslog receiver (the agent has no Datadog destination, so a syslog target is required). The API key is never copied. Verified end to end into a real syslog receiver, with the source configuration accepted by the Datadog Agent itself.
  • Migrate the log collection of a Wazuh or OSSEC agent. luna-migrate wazuh converts the <localfile> sources of ossec.conf (and the shared agent.conf blocks that can be decided for the host): files with wildcards and date patterns, multi-line rules, Linux audit, Windows event channels with their queries, macOS unified log, journald, labels and per-source ignore/restrict rules, forwarded as syslog. The Wazuh manager link, file integrity monitoring and the other Wazuh modules are listed in the report as not migrated. Verified end to end into a real syslog receiver, with the source configuration accepted by Wazuh's own log collector check.
  • Migrate from Elastic Agent. luna-migrate elastic-agent converts a standalone Elastic Agent policy (elastic-agent.yml and inputs.d): each stream with its own processors, the named outputs and use_output routing, and the same <type>-<dataset>-<namespace> data streams in Elasticsearch. A Fleet-managed agent is told to download its policy from Kibana first. Verified end to end into a real Elasticsearch and Logstash.
  • Migrate from Graylog Sidecar. luna-migrate graylog reads the collector configurations a Graylog Sidecar generated (Filebeat, Winlogbeat, NXLog) — from the generated directory or sidecar.yml — and merges them into one agent configuration that keeps each collector's events on its own destinations. The Sidecar's API token is never copied. Verified end to end: each collector's events reached its own receiver with its own filters, none crossed over.
  • Migrate from Promtail. luna-migrate promtail converts a Promtail configuration into an agent configuration that delivers the same Loki streams with the same labels: file, journal, syslog, Windows event and Kubernetes pod targets, the common pipeline stages, per-job drop rules kept scoped to their job, and each Loki client as its own destination. Promtail reached end of life on 2026-03-02. Verified end to end into a real Loki.
  • Migrate from the OpenTelemetry Collector (logs pipelines). luna-migrate otelcol reads the logs pipelines (files, journal, syslog, OTLP, Splunk HEC, Forward, Windows event log), keeps each pipeline's processing and destinations apart, and writes an agent configuration plus a report; metrics and traces pipelines are reported, not carried over. Verified end to end into a real OpenTelemetry Collector.
  • Migrate from NXLog. luna-migrate nxlog nxlog.conf follows define and include, and converts file, Windows Event Log, ETW, syslog-listener and journald inputs, syslog / Snare / Elasticsearch / Kafka outputs, <Route> paths (each destination receives the same inputs as before) and simple Exec drop rules; anything it cannot convert exactly is listed with its line. Verified end to end into a real syslog-ng.
  • Migrate from Fluent Bit. luna-migrate fluentbit reads classic or YAML configurations with their includes and variables. Tag routing (Match / Match_Regex) is kept — each destination receives the same inputs as before and filters stay scoped to their tags; Lua, the Kubernetes filter and rewrite_tag are listed with what to do instead. Verified end to end into a real Fluent Bit.
  • Replace a Splunk Universal Forwarder in one command. luna-migrate splunk reads a forwarder's own inputs.conf and outputs.conf (its home directory, etc/, an app, or btool output — with Splunk's file precedence) and writes an agent configuration plus a report of everything it could not carry over, then validates the result. File monitors, Event Log channels (event-ID filters become a query), network and journald inputs are converted; forwarding groups become HEC destinations on the same indexers, with acknowledgement, compression and per-input routing kept. Every event keeps the forwarder's index, sourcetype, source and host, so existing Splunk searches keep matching — or, with -target syslog, it goes to logrok or any syslog receiver with that metadata attached. The HEC token is never copied from the forwarder's files. See the new guide "Migrating from the Splunk Universal Forwarder". Verified end to end against a real Splunk.
  • Convert Filebeat and Winlogbeat configurations. luna-migrate beats filebeat.yml (or winlogbeat.yml) writes an agent configuration and a report of everything it could not carry over. Filebeat: file, container, journald, syslog/TCP/UDP and Windows Event Log inputs with their exclusions, multiline settings, line filters, fields and tags; Winlogbeat: every event log with its event-ID, level and provider filters as a query, or a custom XML query as is. The Beat's Logstash, Elasticsearch or Kafka output is kept, or everything goes to a syslog receiver. Credentials are never copied. See the guides "Migrating from Filebeat" and "Migrating from Winlogbeat". Filebeat conversion verified end to end against a real Logstash.
  • Per-input fields and host. Every input takes add_fields (fields stamped on that input's events only) and host_override.
  • One HEC output, many indexes. The hec output takes splunk.index, splunk.sourcetype, splunk.source and splunk.host from each event (never sending them as indexed fields), and source_style: splunk sends a file's bare path as its source, as a Splunk forwarder does.
  • Receive GELF. The new gelf_in input accepts GELF (Graylog Extended Log Format) over UDP and TCP — including chunked and compressed UDP messages — so Docker's gelf logging driver and applications that log to Graylog can send to the agent instead. Apex.
  • Receive syslog over TLS. The syslog_in input can now also listen for syslog over TLS (RFC 5425, usually port 6514) with tls_listen, a certificate and optionally client-certificate verification — for firewalls, routers and other devices that send syslog encrypted.
  • Receive what was sent to Splunk HEC. The new hec_in input accepts the Splunk HTTP Event Collector API — event, raw, health and acknowledgement endpoints — so anything that can send to Splunk HEC, such as Docker's splunk logging driver or Kubernetes Splunk connectors, can send to the agent instead. Each request is answered only once its events are durably spooled or delivered. Tokens, HTTPS and client certificates are supported. Apex.
  • Receive OpenTelemetry logs. The new otlp_in input accepts logs over OTLP — gRPC and HTTP (protobuf or JSON) on one port — from applications instrumented with an OpenTelemetry SDK and from OpenTelemetry Collectors, so they can use the agent as their gateway. Each export is answered only once its logs are durably spooled or delivered, so a restart makes the sender retry instead of losing logs. Resource attributes, log attributes and trace ids arrive as event fields; TLS, client certificates and a bearer token are supported. Apex.
  • Send to Fluentd and Fluent Bit. The new fluent output speaks the Forward protocol to a Fluentd or Fluent Bit forward input, so the agent can feed an existing Fluentd aggregation tier. Each request is confirmed by the receiver before the agent counts it delivered; shared-key authentication, TLS and failover are supported, and events received from Fluent Bit keep their original tag. Apex.
  • Receive from Fluent Bit and Fluentd. The new fluent_in input speaks the Forward protocol of Fluent Bit's and Fluentd's forward output — the usual Kubernetes log collector — so a Fluent Bit fleet ships to the agent by changing only its output's host and port. With acknowledgements enabled on the sender, each batch is confirmed only once it is durably spooled or delivered. Shared-key authentication and TLS are supported; Kubernetes metadata arrives as event fields. Apex.
  • Send to Logstash and Graylog. The new beats output speaks the Beats protocol to Logstash's beats input or Graylog's Beats input, so the agent can replace a Beat in front of an existing Logstash pipeline. A batch counts as delivered only once the receiver has acknowledged all of it; a list of receivers gives failover. Apex.
  • Tunable batch size. service.batch_size (default 256, up to 16,384) and service.batch_timeout (default 1 s) set how many events go to a destination per write and how long a partial batch waits. Larger batches raise throughput to receivers with a longer round trip.
  • Receive from Filebeat, Winlogbeat and the other Elastic Beats. The new beats_in input speaks the Beats protocol that Beats use to talk to Logstash, so an existing Beats fleet ships to the agent by changing only output.logstash.hosts. The agent acknowledges each batch only once it is durably spooled or delivered, so a restart makes the Beat resend instead of losing events. TLS and client certificates are supported; Beats fields such as log.file.path or winlog.event_id arrive as event fields. Apex.
  • The agent says why it lost events, and how old its backlog is. Every dropped event is now also counted under one reason — the destination refused it permanently, the spool was full, the spool's disk was too full, no spool was configured, the spool only drains (not licensed), the agent stopped while waiting, or an input's own queue overflowed — and the reasons add up to the existing dropped-events total. Events an SNMP trap, Modbus or ETW input had to drop during a burst were previously counted only inside that input; they now appear in the dropped total, and those inputs report their own counters (for example SNMP traps rejected for their version or community). A new gauge reports the age of the oldest event still waiting in a spool; unlike the delivery-delay gauges it keeps growing while a destination is down, so it can alert on an outage before the spool fills. Under when_full: block, each destination's own back-pressure count shows which one is slowing the sources. All of these are on /metrics and in every heartbeat.
  • Per-group counts instead of floods. The new aggregate processor replaces each group's events (by fields you choose, e.g. host and action) in each time window with one summary event carrying the count and optional sums — so thousands of firewall accepts arrive as a few numbers. Errors and other events you exempt still arrive one by one; summaries of windows still open are lost on a crash (kept on a clean stop).
  • Signed configurations. Pin your own Ed25519 public key in management.config_signing_keys and agents apply a configuration from the control plane only when it carries your signature over its exact text — a compromised control plane cannot push a configuration you did not sign. The agent creates keys (-gen-config-signing-key) and signs files (-sign-config); the control plane must store and serve the signature.
  • Elasticsearch and OpenSearch output. The new elasticsearch output indexes events directly into Elasticsearch or OpenSearch through the bulk API — into a data stream (the default logs-luna-default on Elasticsearch) or an index — as Elastic Common Schema documents, across several nodes. When the cluster throttles or fails some documents, only those are retried, so a partial throttle does not duplicate what already landed; documents the cluster can never index are dead-lettered or dropped and counted.
  • Spool encryption at rest. buffer.encrypt: true encrypts every spooled event with AES-256-GCM (FIPS 140-3 approved) under a key kept outside the spool, so a copied spool directory reveals no event content. If the key goes missing, records are kept and delivery pauses until it is restored. Spool verification and export keep working without the key.
  • Splunk HEC: several endpoints with load balancing and failover. The hec output takes a list of endpoints beside endpoint and either spreads batches across them in turn (load_balance: round_robin) or uses them as backups in order (failover). A batch that fails on one indexer is sent to the next at once instead of waiting in the spool, and a failing indexer is skipped for retry_unhealthy_after (30 s). Indexer acknowledgment works per indexer.
  • Caps on the agent's own resource use. A new limits section sets how many CPU cores the agent may use (max_procs) and a memory budget (memory_limit_mib): near the budget the agent stops reading from its inputs until memory falls again, keeping everything it has already accepted, and reports the pause. A new buffer.min_free_bytes keeps a minimum of free space on the spool's disk during a long outage; what happens to new events at that point follows when_full. All optional; nothing changes for configurations that don't set them.

Changed

  • The Apex modules that 1.x only warned about are now enforced. etw, wmi, linux_audit, mqtt_in, redact, lookup, adaptive_sample and every destination other than syslog have been marked Apex since 1.2.0, and the agent warned that they would be disabled in the next major version. Without a covering license, 2.0.0 removes them at start like every other Apex module and keeps running the rest of the pipeline; posture reads degraded and the startup log names each module removed. Installing a license or enrolling with a logrok control plane restores them at the next start or config reload. See Upgrading to 2.0.0.

  • One service name on every platform: logrok-universal-agent. The systemd unit, the macOS launchd label
    (com.logiqum.logrok-universal-agent) and the FreeBSD rc service (logrok_universal_agent) now carry the
    binary's name, like the Windows service. Upgrading the deb or rpm moves an enabled or running agent to the new
    unit, and logrok-agent stays a systemd alias, so existing commands keep working. The macOS installer unloads
    the old label. On FreeBSD, replace the rc script (see the user guide); your rc.conf settings keep working.

  • The syslog receiver takes in UDP messages faster. In our test on one Linux host with 16 senders, it received about 545,000 messages per second, up from about 375,000, and the share of datagrams lost under load fell from roughly a third to about 0.1%. Message order and content are unchanged; nothing to configure.

  • Syslog output several times faster. Sending to a syslog destination over TCP or TLS is several times faster. On the same machine, eight workers now deliver over 300,000 events per second end to end, up from about 77,000. The wire format is unchanged byte for byte. The Fluent output without acknowledgements is faster the same way, now also over TLS.

  • redact much faster on its built-in patterns. The ipv4, email and credit_card patterns now take far less CPU per event. They redact exactly the same text as before. In our test, eight workers forwarded over 300,000 events per second through redact. Patterns given under regex are unchanged.

  • The syslog receiver scales across more cores. syslog_in receives TCP and TLS streams faster, and latency on a quiet connection is unchanged. Throughput scales as cores are added: in our test on one Linux host, with four processors configured, throughput was about 640,000 events per second on 8 cores, 765,000 on 10 and 850,000 on 14.

  • Faster delivery to several destinations, and to Splunk HEC. When events go to more than one destination, one slow destination no longer limits the others. The Splunk HEC destination takes far less CPU per request (the requests are unchanged); in our test it delivered about 280,000 events per second on 10 cores. Writing to the disk spool is also faster.

  • See where throughput is limited (/metrics). New pipeline_hop_* metrics report, for every step an event passes through (processing, each destination's delivery, its spool writes and spool drain, and the syslog receiver's TCP and TLS streams), how many events it handled, how long it was busy, and how long it waited for work or for the next step. The step with the lowest events per busy second is the one limiting throughput.

  • File tailing keeps up when one file is busy. One busy file no longer limits the others; in our test one file was read at about 195,000 events per second. Latency on a quiet file is unchanged.

  • Faster backlog delivery from the disk spool. The spool delivers a backlog faster. After a crash, a small number of recently delivered events may be sent again; nothing is lost.

  • Inputs resume after a restart by default. filetail, journald, oslog and the Linux audit input (linux_audit, file mode) now save their read position without any setting, in a positions/ folder beside the agent's state file (the service's state directory for the packaged Linux service, the FreeBSD service and the container image). After a restart, a crash or an upgrade they continue where they stopped, so with start_at: end the lines written while the agent was down are delivered instead of skipped. Set the position option (state_path, cursor_file, checkpoint_file) to "" to keep the old behaviour for an input, or to a path to choose the file. On the first start after upgrading nothing is saved yet, so start_at / read_from applies once more. Give inputs a name to keep their position when you edit what they read. windows_eventlog is unchanged.

  • The Linux audit input resumes after a restart. In file mode it now continues from its saved position — including the rest of an audit.log that was rotated while the agent was stopped — instead of starting again from read_from. Live netlink mode cannot resume and is unchanged.

  • One licence for LUnA and logrok: the Logiqum End User License Agreement. The LICENSE file shipped with the agent, luna-migrate, every package and the container image (now under /usr/share/doc/luna/) is the same agreement that covers logrok. It adds, among others, clear terms for the converter's output (your converted configurations are yours), security testing and vulnerability reports, interoperability rights that law guarantees, and the open-source components. Installing or using LUnA means you accept it — -version, -help, the packages and the Helm chart now say so. There is still no accept step, and the agent never checks or reports acceptance. What Core includes is defined in the Licensing guide; nothing that was free has changed.

  • Faster catch-up after an outage. Delivering a spooled backlog is faster than before, so a destination that was down catches up sooner.

  • SNMP trap events use logrok's field names — update any search, rule or dashboard that reads the old ones. Fields are now snmp.version, snmp.user (SNMPv3), snmp.trap_oid, snmp.trap_name, snmp.uptime, snmp.inform, snmp.enterprise_oid, snmp.generic_trap, snmp.specific_trap, snmp.agent_address and one snmp.oid.<numeric oid> per varbind, identical to what logrok's own SNMP listener stores, so one query finds a trap whichever path delivered it. Renamed: snmp_version, trap_oid, trap_name, inform, sysuptime (now printed like net-snmp, e.g. 101 days, 7:56:08.67), enterprise, agent_addr, vb_<oid> (always the numeric OID now, even when oid_names labels it); peer is gone. The event's host is now the address the trap packet came from (previously the device-claimed v1 agent address, which remains in snmp.agent_address), and the default program name is snmptrap instead of snmptrap_in.

  • SNMPv3 AES-192/256: Cisco devices need aes192c / aes256c. aes192 and aes256 now use the key extension net-snmp and most devices use (Blumenthal); before, they used Cisco's (Reeder). With SHA-256 or stronger authentication nothing changes. With SHA-1 or SHA-224, senders other than Cisco now decrypt where they previously failed, and Cisco senders must switch the user to aes192c / aes256c.

  • SNMPv3 MD5 / DES will need an explicit opt-in. Mark each user that relies on auth_protocol: md5 or priv_protocol: des with allow_legacy_crypto: true. This release still accepts them without the flag (and logs a warning naming the user at every start); the next minor release will refuse them without it. The new snmptrap_legacy_crypto_users metric (also in the heartbeat) shows how many such users an agent accepts. In the strict GODEBUG=fips140=only testing mode these algorithms (and all SNMPv3 privacy) are refused at startup with a clear error rather than failing at the first trap. The User Guide's SNMPv3 limitation note now also covers MD5 and DES.

  • SNMP community: [] will be refused. An empty list still accepts any community in this release but warns at startup; write community: ["*"] to accept any on purpose, or list the communities. The next minor release will refuse the empty list.

  • Noise suppression recognises both fingerprint formats. The noise_fingerprint processor now matches events by logrok's newer message-template fingerprint (which masks timestamps, addresses, identifiers and paths, so one rule covers more variants of the same message) as well as by the previous format, so noise rules keep working whichever logrok and agent versions are paired. No configuration change.

  • Enrolled agents keep verifying a control plane with a publicly or corporately issued certificate. In enrolled mode the agent now trusts the system certificate store in addition to ca_file and the CA chain the control plane delivers, so a control plane whose certificate comes from a public or corporate CA no longer stops verifying after enrollment. Set management.tls.system_roots: false to keep trust pinned to the delivered chain and ca_file.

  • Remote upgrade no longer depends on a licence-signing key. A control plane can offer an upgrade to its enrolled agents over an https connection without signing the offer; the agent still verifies the downloaded binary against Logiqum's release signature and runs it once against its configuration before changing anything. Over plain http, or with management.tls.insecure_skip_verify: true, only signed offers are accepted.

  • Noise suppression is faster. The noise_fingerprint processor computes the same fingerprints as before, byte for byte, at a fraction of the CPU cost per event.

Fixed

  • Splunk HEC, Kafka, Loki, Microsoft Sentinel, Cortex XSIAM and Elasticsearch no longer resend what was already delivered. These outputs send a large batch as several requests (or, for Kafka, record by record). When one request of a batch failed temporarily, the whole batch was retried, so the requests that had already been accepted were sent again on every retry and arrived several times. Now only the events that were not accepted are retried, and an event the receiver refuses for good is counted as dropped, and written to the dead-letter directory, once. With Splunk indexer acknowledgment (use_ack: true), requests Splunk confirms as indexed within ack_timeout are no longer resent when another request of the same batch is still unconfirmed. Delivery stays at-least-once: a request whose answer was lost, or one Splunk indexed but did not confirm in time, can still arrive twice.
  • An event that is too large is now rejected once, not on every retry. The OpenTelemetry, Beats and Fluent outputs send a large batch as several requests. When one event was too large to ever be sent and another request of the same batch failed temporarily, the whole batch was retried: the oversized event was counted as dropped, and with on_reject: dead_letter written to the dead-letter directory, again on every retry, and the requests already accepted were sent again. Now only the events not yet accepted are retried. In addition, when a receiver accepts part of a batch and permanently refuses the rest, the refused events are no longer also counted as delivered (events_out); this applies to the OpenTelemetry (including partial success), Beats, Fluent, Splunk HEC, Kafka, Loki, Microsoft Sentinel, Cortex XSIAM and Elasticsearch outputs. If the agent stops while such a retry is pending, the whole batch is sent again after the restart, so events already delivered can arrive twice (at-least-once, as before).
  • Remote upgrade and -check-config accept mutual TLS with the enrolled certificate. Since 1.5.0, -check-config and the check a remote upgrade runs before installing a new version refused every configuration whose output presents the control-plane-issued certificate (cert_source: enrolled with management.tls.mode: enrolled), with "cert_source: enrolled requires management.tls.mode: enrolled", although the agent itself ran that configuration. A remote upgrade of such an agent was therefore refused. Both checks now accept it, so these agents upgrade to 2.0.0 normally; the configuration itself needs no change. A new example, configs/logrok-mtls.example.yaml, shows this setup.
  • The first events of a newly enrolled agent carry its identity. On its first start with an enrollment token, the agent now waits for enrollment to finish before it starts reading, for at most 30 seconds, so the events it reads first carry agent_id and the group the control plane assigned. Before, the events read while enrollment was still in progress had neither, and a search by agent missed them; the group assigned at enrollment appeared only after a restart. If the control plane cannot be reached within 30 seconds, the agent collects anyway and those first events carry no agent_id, as before. File and journal inputs read what was written during the wait; network inputs start listening after it.
  • macOS: a service that cannot start now fails the install. If the agent's LaunchDaemon cannot be loaded after installing the package, the installer reports a failure with the command to retry, instead of reporting success while no agent runs.
  • macOS: uninstalling removes the installer record. After logrok-universal-agent-uninstall, pkgutil no longer lists the agent as installed.
  • OpenBSD and AIX: the agent starts. The OpenBSD and AIX binaries are now built without FIPS 140-3 mode, which the Go Cryptographic Module does not support on those systems; they report FIPS off. Releases 1.3.0 to 1.6.0 for these two systems stop at startup with "FIPS 140-3 mode is not supported"; to keep running one of those until you upgrade, start it with the environment variable GODEBUG=fips140=off. Every other platform keeps FIPS 140-3 mode by default.
  • Container: the disk spool works. In the container image the state directory now belongs to the user the agent runs as, so a configuration with the disk spool (store-and-forward) starts and buffers; before, it stopped at startup with "permission denied". A named volume that an earlier image created and that is still empty takes the new owner on its own; one that already holds files (for example from running the container as root) keeps its owner, so chown -R 65532:65532 it once. A bind-mounted directory must be writable by user 65532.
  • One signature covers every download. Each release now publishes SHA256SUMS.cosign.bundle, a signature over SHA256SUMS made with the Logiqum release key; SHA256SUMS lists every file of the release, so checking the signature and then the checksum verifies any file you downloaded. See "Verify what you downloaded" in the user guide.
  • Packages are signed. Every .deb and .rpm (Full and Crescent, every architecture) and SHA256SUMS (SHA256SUMS.asc) now carry an OpenPGP signature by the Logrok Release Signing key (fingerprint B9BE 1899 A736 BA2C 4B3C 23BF 2BE4 7268 770B 0C3F). rpm --import the published key and rpm -K checks an rpm; debsig-verify with the published policy checks a deb; gpg --verify SHA256SUMS.asc SHA256SUMS checks any file. See the user guide, "Verify what you downloaded".
  • luna-migrate reports FIPS 140-3 mode. Its version output now shows the same fips140: line as the agent, so you can check the converter binary you hold the same way.
  • SHA256SUMS covers every downloadable file. The checksum file now also lists the licence files (LICENSE.txt, NOTICE.txt, LICENSE-APACHE-2.0.txt), and the SBOM records the release version.
  • Debian/Ubuntu: purging removes everything the agent wrote beside its configuration. dpkg -P now also removes the agent's last-known-good copy of agent.yaml, and removes /etc/logrok-universal-agent (and /etc/logrok-agent, if an earlier install still has it) when nothing you added is left in it. Purge also deletes the agent's state folder /var/lib/logrok-universal-agent and the logrok-universal-agent service user; your log folder is left alone.
  • Linux: a service that cannot be enabled or started is reported. The deb and rpm print a warning when enabling or starting the agent fails during install or upgrade, instead of finishing silently.
  • A fresh Linux or macOS install starts with its default configuration. The deb, rpm and macOS packages
    installed the cross-platform reference config, whose paths are Windows paths, so the agent stopped at start
    until the file was edited. They now install a small default for their platform (journal and /var/log on
    Linux; the system log, and the unified log with Apex, on macOS) and ship the reference beside the docs.
  • The agent can read the journal. The Linux packages add the agent's user to the systemd-journal and
    adm groups, so the journald input and root:adm log files are no longer silently unreadable.
  • Upgrading the deb no longer stops the agent. Before, every deb upgrade stopped and disabled the service,
    and it stayed off until someone started it again. The package now restarts a running agent on the new binary.
    For upgrades from older packages the agent is brought back when it was running a moment before the upgrade.
  • AWS Security Lake feed (format: parquet-ocsf): events written while an upload was in progress could be lost. The agent stages events on local disk and uploads them as Parquet objects on a schedule. Events that arrived during an upload were acknowledged and then removed together with the uploaded ones, without being uploaded themselves. They are now kept for the next upload. Two related cases are fixed too: a disk write that failed part-way, and a restart after a crash during a write, could each cause the next acknowledged event to be lost. Affects every release since 1.1.0; nothing to change in the configuration.
  • Windows: saved positions and agent state are written reliably while other software scans them. On Windows, a file cannot be replaced while another program has it open; antivirus, backup and search tools open newly written files all the time. When that happened, the agent's write of a saved read position, its enrollment state, its applied configuration or an upgrade step could fail and wait for the next attempt. The agent now retries such a write for a short moment, so it succeeds once the other program lets go. Separately, a file or audit-log input whose path pattern also matches the folder holding its own saved position no longer reads that position file as if it were a log.
  • The Linux audit input groups events correctly while catching up on an old log. Reading a large existing audit.log (a first start, or catching up after a restart) could fill the input's event buffer and log "reassembly buffer full"; under a heavy backlog an event could then be split in two. Events that consist of a single record (logins, authentication, service start/stop and the like) are now sent the moment they are read, events missing their end marker are completed by the log's own timestamps instead of waiting on the clock, and events from different machines in a combined log that happen to share an event number are no longer merged. Record types that previously showed as UNKNOWN[n] in kernel-socket mode now carry their names.
  • Large rotated .gz archives no longer hold up other files. While the agent read a big compressed archive behind a slow destination, other files' saved positions were not updated until the whole archive was done. Other files now keep being read and their positions saved throughout. An archive is still counted as done only after all its events are delivered.
  • A file input catching up on a large backlog saves its read position as it goes. When a file input had a large amount of unread data and the destination was slow, the input saved its state_path read position only after it had read the whole backlog. A crash or forced stop during that catch-up then sent the entire backlog again after the restart. The read position is now saved continuously while catching up, so a crash re-sends only the last moments. The input also takes turns between files, so one very large file no longer delays every other file the input reads. Compressed .gz files are still read in one go.
  • when_full: block now also covers routed events waiting behind an in-memory spool. With when: routing and an output down on the in-memory spool, more than 65,536 events waiting behind that output's backlog used to move the source's read position on early whatever when_full said. With when_full: block the agent now slows intake until the output catches up instead, so nothing is lost; with drop_oldest (the default) or drop_newest the position still moves on early, and the new metric output_<name>_held_commit_overflow_total counts every such event. A disk spool avoids both.
  • Routed events are no longer skipped at one destination after a restart. With several outputs and when: routing, an event sent only to one output could mark the source's read position as done while an earlier event was still on its way to another output (for example held in memory while that output was down). After a restart, that output never received the earlier event. The read position now advances only once every earlier event is safely stored or delivered at every output it was routed to. While one output is down, the read position of sources feeding it may advance more slowly; nothing is lost.
  • The journald input keeps delivering on journals with future-dated entries. After a host clock incident, a journal can hold entries dated in the future; an input with no unit or identifier filter then stopped receiving new entries. The input now detects this (at start, and whenever such an entry arrives) and switches to reading by position every couple of seconds, so new entries keep flowing without scoping the input. Healthy journals are read exactly as before.
  • The migration tool refuses an out-of-range number in a Vector YAML configuration. An integer larger than the largest signed 64-bit value was converted into a negative number in the migrated configuration. The tool now stops and names the setting.
  • A file input's read position is saved even if the first attempt to save it fails. If writing the state_path checkpoint failed once (on Windows, for example, while an antivirus scanner or another program had the state file open), the agent did not try again until more events were delivered or the next poll_interval. After a restart in that window, the agent could send events again that had already been delivered. It now retries within a fraction of a second, logs one warning when saving starts failing and one notice when it recovers.
  • A configuration the agent rolls back is kept. When a configuration fails to build, the agent goes back to the last one that worked and writes it into the configuration file. It now first saves the configuration it rejected as agent.yaml.rejected beside it (the log line names the file), so a change made by hand is no longer lost.
  • A Windows agent refuses a configuration written for macOS or Linux. If the control plane sends a Windows agent a configuration whose agent paths have no drive letter (for example a state path of /usr/local/var/lib/luna/… from a Mac), the agent now refuses it and keeps running its current configuration. Before, it created those folders on the root of the system drive and kept its state there. A local configuration file with such a path still loads, and -check-config and -self-check warn about it.
  • aggregate now tells you when it stops aggregating. When more groups were open than max_groups allowed, events of the extra groups were forwarded one by one without any sign of it. The agent now logs one warning the first time this happens, and the new processor_<name>_overflow_total metric (also on /metrics and in every heartbeat) counts the events that went through un-aggregated. Raise max_groups or narrow group_by when it is non-zero. No events were ever lost.
  • The Splunk HEC receiver no longer makes a returning sender resend events it already delivered. When more than 10,000 different channels had been seen, the oldest channel was forgotten, and if it came back its acknowledgement ids started again from 0, so a sender polling for the ids it was given was told "not acknowledged" indefinitely and sent the events again. Acknowledgement ids are now never reused, and ids already handed out stay acknowledged.
  • The GELF receiver keeps chunked UDP messages from different hosts apart. Chunks were matched to a pending message by the message id alone, so another host that sent a chunk with the same id could corrupt or complete someone else's message. Chunks are now matched by sending host and message id; memory limits are unchanged.
  • Large OpenTelemetry log batches are no longer rejected. A single export with a very large number of log records, or with many attributes per record (for example about 8,000 records of 125 attributes each), was answered with an "invalid" error, which OpenTelemetry exporters treat as permanent, so the sender dropped the batch. The otlp_in input now accepts such requests, processes them in bounded steps and answers once everything is durable. A record with more than 512 attributes keeps the first 512, is marked with the field otel.attributes_truncated, and is counted in truncated_records_total.
  • The Beats output no longer waits indefinitely on a receiver that only sends keepalives. A receiver that kept answering a window with empty keepalive acknowledgements and never confirmed any events could hold the output (and everything queued behind it) until the agent stopped. The window now fails after ten times the timeout without progress, and the batch is spooled and retried.
  • No more silently lost batches to the Fluentd/Fluent Bit output over TLS without acknowledgements. With require_ack: false over TLS, a connection the receiver had closed while idle could still accept a write, so that batch was counted as sent but never arrived. After a short idle gap the output now opens a fresh connection instead of reusing the old one.
  • A syslog receiver that fails to open one of its listeners can no longer crash the agent. If one listener of a syslog receiver could not be opened — for example the TLS port was already in use, or the socket path was not a socket — while its other listeners had opened, those listeners kept running behind the error, and on a receiver with add_fields or host_override the next UDP message stopped the whole agent with a fatal error. Without those options the receiver was reported as stopped yet kept its port and kept forwarding. The receiver now opens all of its listeners before serving any, and on a failure it releases every one it opened and serves nothing. The syslog receiver also limits concurrent TCP, TLS and stream-socket connections (new max_connections option, default 1024); further connections are closed at once and logged.
  • The Splunk HEC receiver no longer builds huge events in memory before limiting them. A single event carrying hundreds of thousands of JSON keys could make the agent allocate well over 100 MiB while it was parsed, only to keep 512 fields. An event with more than 16,384 keys (at any depth) is now refused up front with 400 "Invalid data format", before any of it is parsed; events below that are handled exactly as before.
  • Events read just before the agent stopped are no longer skipped after a restart. When the agent stopped while a destination could not take its last batch of events — with no disk spool, with only the in-memory spool, with the spool full under when_full: block, or when one of several destinations was down — those events were counted as dropped but still recorded as handled, so after the restart file, journal and Windows Event Log inputs resumed past events that never arrived. On stop the agent now gives the destinations up to the stop grace (service.shutdown_grace, 15 seconds by default) to take the last batch, and anything that is still neither delivered nor written to the disk spool is read again after the restart (senders that wait for the agent's acknowledgement send it again). A destination may receive a few of those events twice; none are skipped.
  • An in-memory spool's backlog is no longer lost when the agent restarts. With a buffer without dir, events held in memory while a destination was down were acknowledged to their input at once, so after a restart a file or journal input continued past them and they were gone. They are now acknowledged only once delivered (or dropped by policy), so the input reads them again after a restart; duplicates are possible, losses are not. While the destination is down, inputs' positions and network acknowledgements wait at the oldest undelivered event.
  • File inputs save their position right after a delivery is confirmed, instead of at the next poll, so a crash re-sends less.
  • Watching live events with /tap can no longer crash the agent. While a tap was open, the agent could stop with a fatal error when a processor changed an event's fields at the moment the tap was writing that event out. Each tap now receives its own copy of the event.
  • -check-config now refuses a misspelt option on the filetail, linux_audit, etw and windows_eventlog inputs. These inputs accepted any option name, so a typo — for example state_file instead of state_path on filetail — passed the check while the setting it was meant to change stayed at its default. Every other input, processor and output already refused unknown options. -check-config now fails on such a key with a message naming the option and the input; remove or correct the key. -self-check, which a remote upgrade runs before installing a new version, refuses it too, so a remote upgrade from 1.x is refused while such a key is in the configuration (see Upgrading to 2.0.0). The agent itself still starts with the key, and now logs a warning naming the ignored option, as it already did for the other modules.
  • A syslog gateway now forwards each sender's program name, process id and message id. A message received by the syslog_in input and forwarded with the syslog output used to arrive with APP-NAME syslog-in and PROCID / MSGID - — the sender's values survived only as structured data. The receiver now sees the original APP-NAME, PROCID and MSGID in the header, and source="syslog-in" in the structured data says the message came through the gateway (the app, procid and msgid structured-data parameters are still sent). The same rule applies to every input: an event with an app field — set with add_fields, or carried over by luna-migrate from an rsyslog file Tag or a syslog-ng program-override() — is sent with that APP-NAME, as the original forwarder did. With encoding: json the header follows the same rules. To keep the previous header (APP-NAME = the source, for example syslog-in or file:<path>; MSGID -), set header_from_fields: false on the syslog output.
  • No more lost batches when a TLS 1.3 receiver refuses the agent's client certificate after the handshake. Under TLS 1.3 the receiver checks the client certificate only after the agent's side of the handshake has finished. A refusal that took longer than a millisecond — an untrusted chain, a rotated or revoked certificate, a certificate without client-authentication usage — let the batch be counted as delivered into a connection the receiver then closed, so every batch was lost while the refusal lasted. The agent now waits for the receiver's verdict before sending (up to 2 seconds, usually much less), and a refusal keeps the batch in the spool for retry.
  • Event-ID filters converted from a Splunk forwarder now work when they contain a range (for example 4700-4702): the generated query was not valid XML, so the agent could not subscribe to that channel.
  • Documentation examples no longer suggest ${VARIABLE} substitution. The agent reads configuration values literally; examples that showed "${HEC_TOKEN}" and similar now show REPLACE_WITH_… placeholders, and the configuration reference says so.
  • OpenTelemetry requests stay under the receiver's size limit. The otlp output sends a batch larger than batch_max_bytes (default 4 MiB, the usual gRPC receive limit) as several requests. Before, such a batch was refused by the receiver and, over gRPC, retried forever, blocking that destination.
  • An event with an impossible timestamp no longer blocks a destination. A time beyond the year 9999 (a sender's bad clock, or a hostile record) could not be written to the spool, and the destination retried forever. Such an event is now stored with the time it was received, and the original timestamp is kept as a field.
  • Far fewer duplicates when a destination is slow rather than down. When writes to a destination keep failing, the agent now waits longer between retries (doubling, up to about 30 seconds) instead of retrying every two seconds, and the OpenTelemetry output gives requests that ran out of time a longer deadline on the next try. Before, a receiver that was overloaded but still storing what it received could be sent the same events many times over.
  • A warning when the spool is configured but not enabled. A buffer section that sets dir (or another option) without enabled: true runs with no spool, so events are dropped during an outage. The agent now says so at startup.
  • The syslog listener no longer loses lines that start with digits. Over TCP, a plain text line beginning with a number — a timestamp like 2026-10-16 12:00:01 …, an HTTP status, an IP address — was taken as a message length: the line was lost and the sender's connection closed. Such lines now arrive as one event each. A new framing option on syslog_in (auto, newline, octet-counting) pins the framing when the sender is known.
  • An in-memory spool (buffer without dir) now frees the memory of events it has delivered. Before, an agent that had buffered a large backlog in memory during an outage kept that memory after the backlog was delivered.

Security

  • Hardened the syslog unix-socket input: the socket is now published atomically so it is never briefly reachable with a looser permission than its configured socket_mode during startup. Previously, on hosts with a permissive umask, there was a short window at startup in which a local user could connect to the socket before the configured mode took effect.
  • An unsigned upgrade offer is refused when the agent does not verify the control plane's certificate. With management.tls.insecure_skip_verify: true the connection does not prove who is on the other end, so someone between the agent and the control plane could have offered an upgrade — still only to a build signed by Logiqum, but to a version of their choosing, including an older one. Such an offer is now refused and reported as refused, naming the setting. Signed offers, and unsigned offers over a verified https connection, are unaffected; rolling an agent back by offering an older version keeps working.
  • Built with Go 1.26.10 and golang.org/x/net v0.60.0, which fix 14 published vulnerabilities in the Go standard library and that networking library (GO-2026-6599, -6600, -6603 to -6605, -6607 to -6613, -6617, and -6809 in 1.26.10).

About these downloads. LUnA ships as signed binaries — the luna-* assets above are the release.
Verify them with SHA256SUMS and cosign (public key: cosign.pub in this repository).

The "Source code (zip)" / "Source code (tar.gz)" links below are added automatically by GitHub to every
release and cannot be removed. They are not the agent's source, and they are empty: this repository
publishes signed binaries and documentation only. LUnA's source is not publicly distributed.