IMD SolutionComputing LibraryShop main store

Troubleshooting

Ignition historian logs memory tags but not OPC tag changes

Edge computing and IIoT Published 8 min read

Short answer

Memory tags record because their history subscription was created fresh; the migrated OPC tags carry a stale recording subscription that a storage-provider field edit alone does not rebuild. Fix one tag first: disable history, save, re-enable history with the production provider, and save again, then verify with one safely forceable fault before batching across the remaining tags.

On this page
  1. Why did tag history stop right after the storage provider switch?
  2. Why does a new memory tag record while the migrated OPC tags stay silent?
  3. How do you prove the live OPC tag changes cleanly before blaming history?
  4. Can the production provider store samples at all?
  5. How do you rebuild the history binding on one tag?
  6. How do you roll the rebuild out across 300 fault tags?
  7. Do you have to delete and recreate the tags instead?
  8. Questions asked

Your OPC tags are healthy; the history binding is stale. Mass-editing only the storage provider field rewrote a stored property without re-registering the tags with the production historian, so every migrated tag still runs the recording subscription it formed against the test database. A memory tag created in the same folder records because its subscription was built fresh. The fix is a full history-property transition on each migrated tag: disable history, save, edit again, enable history with the production provider selected, keep record-on-change, and save. Prove it on one fault operations permits you to force, then repeat the cycle module by module across the roughly 300 fault tags — 50 per module × 6 modules. Rebind the existing tags instead of deleting and recreating them; recreation would add 300 retired identities to sqlth_te on top of the 300 active ones.

Why did tag history stop right after the storage provider switch? #

The provider field edit rewrote a stored property but never rebuilt the recording subscription, so every migrated tag still carries the history binding formed when it was created against the test database, and the production historian never sees a sample from those tags.

Three facts in your own report pin the fault to the binding rather than to the provider, the database, or the network. The tags display the production provider, so the property edit landed. The tags already appear in sqlth_te on the production database, so the historian registered each identity. Nothing new shows up in the old database either, so samples are not being misrouted — for those tags, no samples are being produced at all. Registration and storage are separate events, and a row of metadata is not proof of data.

Observation What it proves What it does not prove
Live Boolean tracks the real fault Controller, driver, and tag path work That the history subscription is active
Every tag shows the production provider The provider property was rewritten That the subscription was rebuilt
Tags appear in sqlth_te The historian registered each identity That any sample reached storage
A new memory tag records Provider and folder can store samples That the migrated bindings are valid
Restarting the folder changed nothing A tag reload is not a binding rebuild That the tags cannot be fixed in place

A missing table would be a different fault entirely — provisioning — and the page why Ignition tag historian tables are not created covers that case. Your tables exist and hold identities, so provisioning is complete and the gap sits between the tag and its sample stream.

Decision: treat this as a stale recording subscription and rebuild the binding; leave the provider and the database alone.

Why does a new memory tag record while the migrated OPC tags stay silent? #

A memory tag created after the switch gets a fresh history subscription at creation, so it registers with the production provider on its first change, while each migrated tag still runs the subscription object formed under the test provider, which the mass edit never touched.

Ignition documents tag history as tag-level configuration in the History section of the Tag Editor, and the effective recording subscription comes from a saved version of that configuration. Two situations record correctly with no extra work: tags created while the production provider was already selected, and tags whose history configuration has been explicitly saved again since the change. Your migrated tags fall into neither group — they were created against the test provider and then had one field rewritten in place.

That is why the symptom reads as a system that works out of the box but fails when transferred: the live tag never changed, only its history context did. It also explains why the restart-tags action on the parent folder did nothing useful here; reloading tag definitions is not a saved history-property transition.

How do you prove the live OPC tag changes cleanly before blaming history? #

Force one fault operations permits, such as a door interlock or an emergency-stop input, and confirm the live Boolean shows both states with good quality; a clean edge pair with nothing stored places the fault downstream of the tag, in the history path.

One safety line before any forcing: actuate only conditions operations has approved, at a safe machine state, and never fire an emergency-stop or interlock on equipment that will keep running just to feed a historian test.

Work one fault end to end:

  1. Record the full tag path, including the PLC folder and the alarm folder.
  2. Force the permitted fault active and note the live value and quality.
  3. Return the condition to normal and confirm the live value follows it back.
  4. Query the same tag and time window through the history consumer the fault table uses.

Test a full edge pair rather than only the active state, because a record-on-change Boolean stores nothing while a fault simply sits high — it stores at transitions. Quality must stay good before, during, and after; a stale or frozen live reading belongs to the OPC path instead, and that upstream failure has its own signature, described in why an OPC DA subscription returns a stale first value.

Can the production provider store samples at all? #

Yes — one controlled toggle of the memory tag you already have proves it: keep that tag on the production provider with record-on-change, force it through both states, and expect exactly 2 stored samples for the 2 forced edges inside a narrow query window.

Worked example: force the memory tag false to true at 10:42:05 and back to false at 10:42:40, then query production history for 10:41:00 to 10:44:00. Record-on-change stores one sample per transition, so 2 transitions × 1 sample per transition = 2 stored rows. Two rows clear the provider, its database connection, and the query path in one shot.

Zero rows behind a clean toggle means the fault is provider-side: confirm the provider is enabled in the gateway's tag history configuration, and check the store-and-forward queue for stalled data. Samples appearing only under the old provider would mean the old provider is still effective somewhere in the configuration.

Decision: memory tag records both edges — the provider is proven, and the only remaining difference between a recording tag and a silent one is the binding.

How do you rebuild the history binding on one tag? #

Rebuild one tag with a full history-property transition: disable history and save, then edit the same tag again, enable history, select the production provider, keep record-on-change, and save again; that second save re-registers the tag with the production historian.

Pick the fault tag whose live behavior you proved above, and capture its path and history settings first so the fault table keeps working unchanged. Each save in the cycle matters, because saving forces the historian to re-register the tag against whatever provider is selected at that moment.

The pass criterion is narrow: one forced edge pair on the original tag path returns 2 stored samples, and the fault table still resolves that path to exactly one live fault. If the pilot records, the method is proven. If it still records nothing after a genuine disable-save, enable-save cycle, stop editing tags and recheck the provider side — a per-tag rebuild cannot fix a provider that is disabled or stalled.

Keep the tag in place throughout. This is a rebind of history properties, not a delete-and-recreate, so the code that filters on tag path never meets a second copy.

How do you roll the rebuild out across 300 fault tags? #

Batch by module once the pilot passes: about 50 faults per module across 6 modules gives 50 × 6 = 300 tags, so rebind one module at a time and verify each batch with one forceable fault from that module before moving on.

Skip the rare process faults as rollout evidence. They give you no predictable transition time, and a query-window or timestamp mistake then looks identical to a recording failure. Verify each module with one fault from the forceable set instead.

Batch arithmetic: 1 pilot tag proves the method; 50 faults per module × 6 modules = 300 tags; one forced verification per module gives 6 verification cycles, and 2 samples × 6 cycles = 12 stored rows across the whole rollout. A batch that verifies clean cannot hide a stale subscription, because the verification samples come from that module's own tags.

Decision: module-sized batches, one forced verification each; the final module's clean 2-row result closes the job.

Do you have to delete and recreate the tags instead? #

No — keep the tags and rebind them; recreating 300 tags would add 300 retired identities on top of 300 active ones in sqlth_te and put duplicate paths in front of the fault-table filter, while a rebind preserves every live tag path the HMI code already filters on.

Worked example of what recreation costs, assuming sqlth_te holds about 1,500 identities today: recreating 300 tags inserts 300 active and 300 retired identities, so fault identities reach 600 of 1,500 rows, which is 600 / 1,500 = 40% of the table by volume, of which 300 / 1,500 = 20% are dead rows. Those retired identities are historian storage metadata, not the HMI's logical fault identity. A contiguous block of tagid values fragments the moment tag 301 is added, while filtering the fault table on tag path keeps the code aligned with the plant's fault hierarchy.

Leftover historian metadata after a history reconfiguration is a known pattern, and the page stale historian tag browse tree entries after a restore shows how stale entries confuse downstream consumers. With 300 on-change fault tags now writing to production, set retention so the table grows on your terms; the settings are walked through in setting historian pruning and retention for Ignition tag history.

Decision: rebind the existing tags, filter the fault table on tag path, and reserve delete-and-recreate for a single-tag trial that proves the fault table still resolves cleanly before anyone recreates 300.

Questions asked

Does a row in sqlth_te prove a tag is recording?

No. The identity row is written when the historian first registers the tag, and it can sit there with no samples behind it at all. Each row also carries a retirement marker that sets when the tag is deleted or recreated, which is why recreated tags leave dead rows behind. Check for stored samples in a query window, not for the row.

In what order should the diagnostic checks run?

Confirm a clean live edge pair on the OPC tag first, then prove the provider with the memory tag, then rebind one tag and verify it, then batch by module. Each step gates the next, so a disabled or stalled provider is never mistaken for 300 broken tag bindings, and a binding fault is never blamed on the database.

Can all 300 tags be rebound in one bulk edit instead of batches?

The same edit applies to any number of tags, but a bulk change that misses the save transition on every tag at once multiplies the rework. Run the single-tag pilot, then module-sized batches with one forced verification each, because 50 tags per batch keeps each verification query narrow and any rollback small.

Will 300 record-on-change fault tags flood the production historian?

Volume follows change frequency, not tag count. A fault that trips and clears stores 2 rows per occurrence, and a fault that never changes stores none, so 300 quiet tags add almost nothing. Set a pruning and retention schedule so old fault rows are removed on a fixed cadence instead of accumulating indefinitely.

Would putting the faults in a UDT have avoided this?

Probably yes for future builds: enabling and saving history once on a UDT definition rebinds every instance together, instead of editing each plain OPC tag by hand. This fault set was built as standard OPC tags, so the per-tag disable-save, enable-save cycle is the path; a UDT migration is optional cleanup, not part of the fix.

Keep reading

  • Troubleshooting

    Historian reads slow in Excel after adding tags

    Run one timed test before touching anything: read one old tag and one newly added tag over the same range in the historian's built-in client, then in the Excel macro. Fast in the client but slow in Excel means the macro's request pattern is the fault; the new tag slow in both means you run the historian's validate action and then confirm the SQL maintenance plan actually targets the historian database.

    Edge computing and IIoT

  • Troubleshooting

    Stale historian tag browse tree entries after a restore

    A historical tag browse tree lists the identities the edge historian has stored samples under, and a gateway restore replaces live tag configuration without touching that store. On a disposable development machine, stop the gateway, move the local .idb file out with a copy kept, and restart to clear them; Root Node Path trims the visible hierarchy without deleting data.

    Edge computing and IIoT

  • Explainer

    Do you need a historian or just an OPC tag server?

    No. An OPC tag server (OPC DA) supplies the current value, quality and timestamp of each item and stores nothing, so monthly figures need a historian or a SQL logger collecting from that same server. Keep a reporting client like ActiveFactory only if you also run the historian it expects.

    Edge computing and IIoT