How to Implement a Unified Namespace: Plain MQTT or OPC UA

This article was created with AI assistance.

A Unified Namespace is usually built on plain MQTT. It doesn't have to be — and the alternative fixes several problems MQTT-based UNS projects run into once they scale past the pilot.

1Introduction to UNS

A Unified Namespace (UNS) is a single, live, hierarchical source of truth for operational data across a plant or enterprise. Instead of wiring point-to-point integrations between every PLC, SCADA system, MES, and cloud application, every system publishes into — and subscribes from — one shared namespace. It has become a foundational pattern in Industry 4.0 and Digital Transformation initiatives because it decouples data producers from data consumers: adding a new consumer means subscribing to existing data, not building yet another custom interface to yet another data source.

The typical implementation: MQTT broker + ISA-95 topic hierarchy

The most common way to build a UNS today is around an MQTT broker as the central nervous system. Devices, PLCs, and applications publish and subscribe to topics, and the broker fans messages out to whoever is listening. The topic tree is usually organized to mirror the ISA-95 equipment hierarchy — enterprise, site, area, production line, and work cell/asset — so a topic name alone tells you where in the physical plant a value came from, for example enterprise/site/area/line/cell/tagName.

PLAIN MQTT UNS Publishers PLC / SCADA MES / gateways (custom payload & topic per source) MQTT Broker Topic tree (ISA-95 style) enterprise / site / area line / cell / tagName no browse API, no history, no request/reply Subscribers Dashboards Historian bolt-on Cloud / analytics Everything a new subscriber needs to know about the topic tree — names, structure, payload shape — has to be documented and shared out of band, because MQTT itself has no way to browse or describe what's published.

A typical MQTT-based UNS: publishers push to a broker organized as an ISA-95 topic tree; subscribers read what they need — but nothing about the tree is discoverable from the protocol itself.

Pros and cons of MQTT-based UNS

Pros

  • Lightweight, simple pub/sub model with a low barrier to entry
  • Decouples publishers from consumers — add a subscriber without touching the source
  • Huge ecosystem: open-source brokers (Mosquitto, EMQX, HiveMQ), client libraries in every language, native support in most cloud IoT platforms
  • Works well over constrained or unreliable networks
  • Easy first step — a pilot UNS can be running in days

Cons

  • Payload format is not standardized. MQTT only moves bytes; every team invents its own JSON schema (Sparkplug B helps but is adopted inconsistently and is its own layer to agree on and maintain)
  • No access to historical data. The broker only knows the latest retained value — a historian has to be bolted on separately, with its own query interface
  • No feature for synchronous requests, including transactional calls — pub/sub has no built-in request/response, so writing back to a device or invoking an action needs an entirely separate mechanism
  • No support to browse the topic structure. Topics aren't self-describing; a new client has to already know the tree from external documentation, since MQTT has no discovery or introspection API
The question this raises Is it possible to build a UNS on a protocol other than MQTT — one that doesn't have these gaps?

2An Alternative: OPC UA as the Core Protocol

OPC UA is an IEC 62541 standard maintained by the OPC Foundation, built specifically to solve the problems above. Relevant to a UNS, it provides:

  • A browseable, discoverable address space — the information model is a hierarchy of objects, variables, and methods that any client can walk and inspect at runtime, no external documentation required
  • A well-defined payload format for published data, carrying value, quality, and both server and source timestamps as standard parts of every reading — not an ad-hoc JSON shape each team has to agree on
  • True report-by-exception, with server-side monitored items supporting both absolute and percent-based deadbands, so only meaningful changes go over the wire
  • Native support for both real-time and historical data through the same address space and the same client APIs
  • Built-in support for alarms and events, not a separate system bolted on afterward
  • A lighter footprint on the wire than it gets credit for: despite MQTT's "lightweight" reputation, MQTT/JSON payloads commonly run three times or more the size of the equivalent OPC UA binary-encoded payload for the same data

OPC UA also supports a Publish-Subscribe transport mode of its own — including over MQTT — so choosing OPC UA as the core protocol doesn't mean giving up MQTT transport where it's useful; it means the payload, the address space, and the semantics riding on top of it are finally standardized.

Implementing UNS with oBox Suite

oBox Suite from One-Way Automation is a modular platform for building exactly this kind of OPC UA-centric UNS. Its three main modules are:

  • Protocol Converter — south-bound connectivity to virtually any industrial data source: PLCs, RTUs, SCADA and DCS systems, CNC machines, and robots from mainstream and legacy vendors alike
  • Model Designer / Data Harmonizer — a WYSIWYG, web-based editor for building a hierarchical, ISA-95-aligned address space, turning raw tags into meaningful objects (for example, a Pump with Temperature and Pressure attributes) instead of a flat list of points
  • Data Logger — stores and forwards data, both real-time and historical, to downstream databases and messaging systems

That combination gives a UNS built on oBox Suite a few concrete advantages over a bare MQTT broker:

  • Southbound connectivity to virtually any industrial data source through the Protocol Converter module
  • A WYSIWYG, browser-based editor for the address space, with a real hierarchical structure — not a topic-naming convention enforced by hand
  • Support for a layered deployment: local site-level edge instances that push harmonized data up to a centralized cloud instance
  • Multiple, standards-based interfaces for higher-level applications to consume the same data:
    • OPC UA — real-time data via standard OPC UA subscriptions and monitored items; Pub/Sub over MQTT or brokerless UDP; and historical data, both raw and processed
    • REST API for lightweight application integration
    • MCP for straightforward integration with AI-based solutions
    • A built-in MQTT broker, so applications that only know how to subscribe over MQTT are still fully supported
OPC UA + OBOX SUITE UNS Field devices PLC / DCS / SCADA CNC / robots oBox Suite (edge) Protocol Converter Model Designer (harmonized) Data Logger Interfaces OPC UA subscribe OPC UA Pub/Sub (MQTT/UDP) Historical (raw / processed) REST API MCP (AI integration) Built-in MQTT broker Applications MES / analytics AI agents / cloud oBox Suite (cloud) centralized instance, multiple sites merged Site-level edge instances harmonize local data and push it up to a centralized cloud instance — the same browseable, standardized address space at every layer.

UNS built with OPC UA and oBox Suite: harmonized address space at the edge, layered up to a centralized cloud instance, exposed through OPC UA, REST, MCP, and MQTT.

3MQTT-Only vs. OPC UA + oBox Suite

DimensionPlain MQTT UNSOPC UA + oBox Suite
Payload format Not standardized — every team defines its own JSON schema Standardized OPC UA data value: value, quality, server and source timestamps
Historical data Not available from the protocol — a separate historian must be bolted on Native raw and processed historical access via the Data Logger module
Synchronous / transactional calls Not supported — pub/sub only, no request/response Supported via OPC UA services and method calls
Browsing / discovery of structure Not supported — topic tree must be documented and shared out of band Address space is browseable and self-describing by design
Report by exception Depends entirely on how each publisher is coded Built-in, with absolute and percent-based deadbands on monitored items
Alarms & events No native model — typically a separate system Native OPC UA alarms & events
Bandwidth efficiency JSON over MQTT — commonly 3x+ the size of the OPC UA binary equivalent Compact OPC UA binary encoding
Southbound connectivity to legacy/industrial sources Left to whatever publishes into the broker — usually custom, per source Protocol Converter module covers PLCs, RTUs, SCADA/DCS, CNC, robots out of the box
Building the address space / hierarchy Enforced only by topic-naming convention and discipline WYSIWYG Model Designer / Data Harmonizer, ISA-95-aligned
Edge-to-cloud layering Possible via broker bridging, configured and maintained by hand Built-in layered edge → cloud instance support
Integration interfaces MQTT only OPC UA (subscriptions, Pub/Sub over MQTT or UDP), REST API, MCP, plus a built-in MQTT broker
AI integration Custom, built by hand against the topic schema Native MCP interface

4Wrapping Up

Plain MQTT is a perfectly reasonable way to get a UNS pilot running quickly, and its ecosystem is hard to beat for raw reach. But the gaps that show up once a UNS moves past a pilot — no standard payload, no history, no synchronous calls, no browsing — aren't quirks of a particular broker; they're gaps in MQTT itself. OPC UA closes all four by design, and a platform like oBox Suite turns that into a practical UNS implementation: south-bound connectivity to the plant floor, a real hierarchical address space you build visually instead of by naming convention, and northbound access over OPC UA, REST, MCP, or MQTT — so applications that only speak MQTT still aren't left out.

References

  1. [1] OPC Foundation — OPC UA overview, address space, PubSub, and historical access: opcfoundation.org/about/opc-technologies/opc-ua/
  2. [2] One-Way Automation — oBox Suite: onewayautomation.com/obox-suite/

Idako vs. Telegraf: Two Ways to Log OPC UA Data to InfluxDB

This article was created with AI assistance.

Both can move process data from an OPC UA server into InfluxDB. They're built on very different assumptions about what else your pipeline needs to do — here's how to pick.

Telegraf is InfluxData's open-source metrics collection agent — a single Go binary with 300+ plugins covering everything from system metrics to databases, cloud APIs, message queues, and (via community-maintained plugins) OPC UA. Idako is a purpose-built OPC UA-to-database bridge: a much narrower tool that does one job — reading from OPC UA servers and getting that data into InfluxDB, SQL databases, or messaging platforms without losing samples along the way.

Neither is "better" in the abstract. Which one fits depends on what else is in your stack, who configures it, and how much you need OPC UA specifically — as opposed to metrics collection in general — to just work.

1The Short Version

Choose Idako if…

  • OPC UA is your primary or only data source
  • You want a GUI, not TOML files, for OT technicians to maintain — or SQL/REST access for automation
  • You need guaranteed store-and-forward buffering by default
  • Your servers expose complex/structured (ExtensionObject) data types
  • You want tags selected by scripted (Python) rules and mapped by template, not listed by hand one at a time
  • You need two-node HA for zero-downtime maintenance
  • You want a single vendor to call when something breaks

Choose Telegraf if…

  • You already run Telegraf for other metrics (hosts, containers, APIs)
  • You need one agent to also collect from dozens of non-OPC UA sources
  • Your team is comfortable in Go-ecosystem tooling and config-as-code
  • Budget requires a fully open-source, license-free tool at any scale
  • Your OPC UA tags are simple scalar types (no ExtensionObjects)

2What Each Tool Actually Is

Telegraf

Telegraf is part of InfluxData's TICK stack — the same company that makes InfluxDB. It's a general-purpose, plugin-based collection agent configured with TOML files. For OPC UA specifically, it ships two separate input plugins: opcua, which polls a configured list of nodes on a fixed interval, and opcua_listener, which opens a true OPC UA subscription and streams changes as the server reports them [1]. Output goes through the influxdb_v2 (or influxdb for 1.x) plugin, one of roughly 100 supported outputs.

Idako

Idako (formerly ogamma Visual Logger for OPC) is built around a single job: bridge OPC UA servers to storage and messaging targets — InfluxDB, TimescaleDB, MS SQL/MySQL/PostgreSQL, Kafka/Confluent/Redpanda, MQTT, Snowflake — with native OPC UA subscriptions, millisecond (microsecond with InfluxDB) timestamp resolution, and Store & Forward buffering as a first-class, on-by-default feature rather than an add-on. Its own configuration lives in a SQL database (SQLite for single-node installs, PostgreSQL for larger or clustered deployments) rather than a flat file — so you can change it from the GUI, by editing the database directly, or programmatically through a REST API, whichever fits your ops workflow.

3Architecture, Side by Side

IDAKO PATH OPC UA PLC / DCS / SCADA Idako Native subscribe + buffer Forward (Store & Forward on) InfluxDB TELEGRAF PATH OPC UA PLC / DCS / SCADA Telegraf opcua / opcua_listener input influxdb_v2 output (+ 99 others) InfluxDB Buffering on by default, disk-backed In-memory by default; disk mode is opt-in

Both draw the same box diagram at a glance. The difference is in the boxes: Idako's collector and forwarder are one purpose-built component; Telegraf assembles the same pipeline out of two independently-maintained, general-purpose plugins that happen to be able to talk to each other.

4Head-to-Head

DimensionIdakoTelegraf
OPC UA subscriptions Native from the start — event-driven with per-tag deadbanding Supported via opcua_listener (added in Telegraf v1.25) [1], separate from the older polling-only opcua plugin
Complex / structured data types Full support for vendor-specific structured types (custom binary decoding) Reading OPC UA ExtensionObjects is a known open limitation — errors out on many structured-type nodes [2]
Store & Forward buffering On by default, disk-backed, sized for your outage window out of the box In-memory buffer by default (metric_buffer_limit); a disk-backed WAL buffer exists but is still flagged experimental, with manual disk-space management and reported edge-case bugs [3]
Configuration storage & access Held in a SQL database (SQLite or PostgreSQL) — edit via GUI, direct SQL, or REST API Flat TOML config file, hand-edited or templated by external config management
Variable selection Manual pick in the GUI, or Python-scripted selection rules (e.g. "log everything under this folder matching X") run from the GUI on demand Listed explicitly, node by node, in the TOML config file
Measurement / tag mapping Set per variable individually, or generated automatically from templates so hundreds of similar tags map consistently without per-tag editing Set per node block in TOML; no built-in templating engine — bulk/consistent mapping across many tags is typically scripted outside Telegraf
High availability Native 2-node HA cluster — automatic failover and maintenance (e.g. upgrades) without a collection gap No built-in HA; redundancy means running independent agents and deduplicating downstream, or leaning on external orchestration (systemd/Kubernetes restarts)
Output destinations Curated set: InfluxDB, TimescaleDB, SQL databases, Kafka/Confluent/Redpanda, MQTT, Snowflake ~100 output plugins — InfluxDB is one of many, alongside Prometheus, Kafka, cloud monitoring services, and more
Non-OPC UA data sources Out of scope by design 200+ input plugins for hosts, containers, databases, cloud APIs, and other industrial protocols
Licensing / cost Community Edition free forever (≤64 tags); paid Standard Edition beyond that Fully open source (MIT), free at any scale
Support model Vendor support from One-Way Automation Community forums / GitHub issues, or a paid InfluxData support contract
Deployment Windows, Linux, Raspberry Pi, Docker; optional 2-node HA cluster Windows, Linux, macOS, Raspberry Pi, Docker — very portable single binary

5Where Telegraf Genuinely Wins

If OPC UA is just one of several things you're collecting — say, host metrics from your edge servers, container stats, and API health checks alongside process data — running one Telegraf agent for all of it is simpler than running Idako plus a separate metrics agent. Telegraf's plugin ecosystem is enormous, it's free without a tag-count ceiling, and if your OPC UA tags are all simple scalar types, both its polling and subscription-based inputs work well. It's also the natural choice if your team already standardizes on InfluxData tooling (Telegraf, InfluxDB, Chronograf/Grafana) and is comfortable maintaining TOML configs as code.

6Where Idako Genuinely Wins

When OPC UA reliability is the project — not a side input among many — the gaps close in Idako's favor. Store & Forward isn't something you have to opt into and tune around known bugs; it's the default behavior. Structured/ExtensionObject tags, common on DCS systems and vendor-specific PLC blocks, are handled natively instead of erroring out. And a GUI-driven config means the OT technician who owns the PLC, not necessarily the person who knows TOML syntax, can maintain the tag list. For a plant where OPC UA-to-historian is the whole job, that focus tends to matter more than plugin count.

A few differences matter specifically once you're managing more than a handful of tags:

  • Config lives in a real database, not a text file. Idako's own configuration is stored in SQLite or PostgreSQL rather than a flat TOML file, so a change can come from the GUI, a direct SQL statement, or a REST API call — useful if you want another system (a provisioning tool, an MES) to manage tags programmatically instead of hand-editing config.
  • Selection logic, not a hand-built list. Instead of listing every node by hand, Idako lets you define selection rules in Python — e.g. "log every variable under this folder whose name matches this pattern" — and run that selection from the GUI to (re)populate the tag list in one step, instead of adding nodes one at a time.
  • Mapping scales with templates. You can map OPC UA attributes to InfluxDB measurements and tags one variable at a time, or define a template once and apply it across hundreds of structurally similar tags — consistent naming without hand-editing each one.
  • Built-in 2-node HA. Idako supports deployment as a high-availability cluster across two nodes, so a node failure or a planned upgrade doesn't create a collection gap — maintenance becomes a non-event instead of a scheduled outage window.
Not mutually exclusive These tools coexist well. A common pattern: use Idako to pull OPC UA data reliably — especially anything with structured types or strict no-data-loss requirements — into InfluxDB or Kafka, and run Telegraf alongside it to collect infrastructure and application metrics from the same edge gateway into the same InfluxDB instance. You get purpose-built OPC UA handling without giving up Telegraf's broader collection footprint.

7Wrapping Up

Telegraf is the right tool when OPC UA is one data source among many and you want one open-source agent to rule them all. Idako is the right tool when OPC UA is the core of the job and you can't afford the pipeline to quietly drop a structured tag or lose an hour of data during a network blip. Most plants end up choosing based on which failure mode they're more worried about: missing a plugin, or missing data.

References

  1. [1] InfluxData, "Yes, You Subscribed Correctly. The OPC UA Client Listener Plugin Has Been Released!" — influxdata.com/blog/opc-ua-client-listener-plugin/; Telegraf opcua_listener and opcua input plugin docs — docs.influxdata.com/telegraf/v1/input-plugins/
  2. [2] Telegraf GitHub issue #9911, "OPC-UA Client: Support for ExtensionObjects" — github.com/influxdata/telegraf/issues/9911
  3. [3] Telegraf output buffer strategy spec (tsd-005) and related disk-buffer issues (#15876, #15868, #16500, #16670, #18085) — github.com/influxdata/telegraf