Explainer
AVEVA Historian Connector redundancy options explained
Short answer
AVEVA Historian Connector v3.1 does not manage failover between redundant Historians. For collection redundancy, run two Connectors, each writing to its own Historian, with configurations you keep identical by procedure; use Historian partner and client failover only to cover temporary access loss.
On this page
- Does the AVEVA Historian Connector support redundant Historians?
- Which failure am I actually protecting against?
- How do I build redundant collection from Plant SCADA?
- What does partner Historian failover actually cover?
- How do other data sources change the design?
- Where should the second Connector run?
- How do I keep the two Connector configurations identical?
- How do I test the redundancy I actually built?
- Questions asked
No — AVEVA Historian Connector v3.1 does not manage failover between redundant Historians, and that single fact sets the architecture. Its Plant SCADA redundancy connects to a primary/standby server pair through a client, which puts one extra machine in the path. The documented answer for collection redundancy is two Connectors, each sending to its own Historian, with configurations kept identical by procedure. Partner Historian functionality and client failover cover a different failure: temporary loss of access while a Historian is offline. Pick the design from the failure you must survive; the sections below walk that choice in the order you meet it.
Does the AVEVA Historian Connector support redundant Historians? #
No. At v3.1 the Connector forwards and synchronizes to a single Historian destination, and no option in this version chooses between a redundant pair; redundancy has to be built around the Connector, not inside it.
The redundancy v3.1 does have is on the source side: the Connector reaches a primary/standby Plant SCADA server arrangement through a client. That works, but the client machine becomes part of the redundancy — with the client down, both SCADA servers can be healthy and the Connector still has no path. On the destination side, nothing switches between Historians for you.
That asymmetry is why the workable designs below put redundancy either in a second collection path or in the clients, never in the Connector itself.
Which failure am I actually protecting against? #
Three failures matter: data that never reaches a Historian (collection), stored data that is lost (storage), and a Historian that is temporarily unreachable (access) — each has a different fix, and only collection needs two Connectors.
| Failure | What it looks like | The fix that fits |
|---|---|---|
| Collection | Source data reaches no Historian; tags gap everywhere | Source-specific redundancy: for Plant SCADA, two Connectors each writing to a separate Historian |
| Storage | History is lost after a disk or machine failure | Backups plus reliable disk; RAID 1, 5 and 10 are the levels to weigh |
| Access | A Historian is temporarily offline, for example for a security update | Partner functionality and Historian Client Desktop failover |
AVEVA Historian also supports replication of collected data to another Historian, to AVEVA Insight, to AVEVA Data Hub or to a PI System — a copy of what has been collected, not a second collector.
The decision at this step: collection risk takes independent paths, storage risk takes disks and backups, access risk takes a partner pair. Everything below follows from that one sentence, and a second Connector bought for an access-only problem is effort spent on the wrong failure.
How do I build redundant collection from Plant SCADA? #
Run two Plant SCADA Connectors, each configured to send its data to a separate Historian; that gives two independent collection paths and removes the client machine from the redundancy, at the cost of keeping both configurations identical yourself.
| Approach | Collection path | What it costs you |
|---|---|---|
| Connector through a client | Connector reaches the primary/standby Plant SCADA servers via a client machine | The client is a single dependency inside the redundancy |
| Two Connectors | Each Connector collects and sends to its own separate Historian | Two configurations you must keep identical by procedure |
The same two-connector shape serves a different purpose when you are moving systems rather than building permanent redundancy: you can run two Plant SCADA Historian connectors during a migration and retire one at cutover.
The single-destination limit is not unique to this version: the Citect SCADA Connector documentation allows one forwarding destination — Historian on-premises or AVEVA Insight — so for that source, collection redundancy has to come from the arrangements around the Connector. Where that Historian machine should sit relative to the SCADA servers is its own question, answered in where to install Historian alongside Citect SCADA.
What does partner Historian failover actually cover? #
Access only. In a partner pair the Historian Client automatically detects and selects the online Historian, so operators keep trending through a patch window — but the two servers do not synchronize automatically, so client failover proves nothing about matching history.
You build the pair in the Historian configuration reached through OCMC, configuring the backup on the primary node. From then on, client selection of the online server is what keeps trends alive while one machine is down.
Two limits keep this an access solution. First, the servers in the pair are not synchronized automatically: data collected into one while the other was offline stays unequal until you deliberately backfill. Second, Historian Client Trend failover relies on consistent tag names, so a successful failover tells you the client found the tags, not that both servers hold the same history.
The redundant AppEngine arrangement behaves differently, and the difference matters: there, the AppEngines synchronize data before sending it to the Historians, which is why that architecture does not lean on Historian-to-Historian synchronization. Do not carry that expectation into the two-Connector design.
How do other data sources change the design? #
By source: Application Server uses redundant OI Servers with redundant AppEngines, Remote IDAS uses two instances with separate Communication Drivers and channels, and InTouch uses parallel tag logging — the two-Connector pattern belongs to Plant SCADA collection.
For Application Server sources, the redundant OI Servers with redundant AppEngines are the documented pattern, with the synchronization happening upstream of the Historians as described above.
Remote IDAS gives you two choices. Run two Remote IDAS instances, each collecting through its own Communication Driver instance and channel, each sending to a separate Historian. Or run one instance with Communication Driver failover — but one instance cannot combine driver failover with store-forward. If network interruptions are the risk you actually face, commit to the two-instance design so store-forward stays available on each path.
InTouch sources take another route entirely, running redundant InTouch historians with parallel tag logging rather than anything connector-side. Every one of these arrangements shares the same operating cost: separate paths mean user-managed configuration parity.
Where should the second Connector run? #
On its own host, ideally next to the Historian it feeds — a fanless mini PC is a common choice for an edge collection box — so one hardware or OS failure cannot stop both paths at once.
Separate hosts also separate the patching calendars: you can update one path without touching the other, which is exactly the kind of outage this design is meant to absorb. Keep each Connector close to the Historian it writes to, so a network or site failure does not take both collection paths with it.
How do I keep the two Connector configurations identical? #
By procedure, not by tooling: there is no automatic configuration synchronization between Connectors, so every scope or destination change is made twice, checked twice, and recorded with who made it and when.
Compare the configured collection scope and the destination on both paths whenever either changes, so an edit on one side cannot silently route data differently from the other. Write down which Connector and which Historian each path uses, and name the person or role that owns parity — undocumented parity is how a tag appears on one Historian and not its partner.
How do I test the redundancy I actually built? #
Test collection and access as separate outcomes over a planned window: stop one Historian, confirm the other path keeps collecting, confirm the client fails over, then compare both Historians for the window before calling the design redundant.
Worked example, with illustrative numbers you replace with your own: 250 tags, one sample per tag every 10 s, and a 15-minute planned stop of Historian A. Expected collection on the surviving path: 250 tags × 6 samples per tag per minute = 1,500 samples per minute; 1,500 samples/min × 15 min = 22,500 samples.
Pass criteria: a known tag on the surviving Historian shows values and timestamps across the whole window; the client trend stays live through partner failover during the stop; and after restart, Historian A shows a gap of the same 22,500-sample extent unless you deliberately backfilled it. Do not score the test by row counts alone — counts move with logging triggers, buffering and retention, so confirm a known tag, value and timestamp instead.
Schedule the stop in a window where a gap on the tested Historian is acceptable, and tell operations which trends will point at the partner while it runs.
The decision, case by case: for access-only outages, a partner pair plus client failover and nothing else. Where collection must survive, two Connectors, each to its own Historian, on separate hosts, parity by procedure. For storage loss, RAID and backups, not more collectors. For network interruptions on a Remote IDAS path, two instances with store-forward rather than one instance doing driver failover.
Questions asked
Will a future Connector release add redundant Historian failover?
Nothing has been announced, so build the two-Connector pattern on the assumption that connector-managed failover stays absent. When you upgrade the Connector, read the release notes for the exact version you are moving to before collapsing two paths into one.
Is Historian replication a substitute for two Connectors?
No. Replication copies data after the first Historian has already collected it, so any failure between the source and that Historian still loses the samples. It is the right tool when the risk is losing a stored copy, and the wrong one when the risk is losing collection.
How are alarms and events handled on a redundant Historian pair?
Both Historians in a redundant setup must be configured to store events to the same location, with history blocks one documented option. If they store events separately, event history splits across machines and reports read incompletely from either server.
What happens to the data on a Historian while it is offline?
The offline window stays a gap on that server, because the pair does not synchronize automatically. Keep collecting on the second path, then backfill deliberately, from store-forward where the source supports it or by replication, and verify the result against a known tag and timestamp.