Troubleshooting Ignition Window Tag Reference Tracking

The tag reference tracker reports runtime subscriptions from a Vision client. It does not produce a complete static dependency list for an individual window. That distinction controls the audit: capture subscribed tags one window at a time, then separately review scripted reads and dynamically assembled tag paths.

Audit Boundary and Definitions

A subscription is a persistent runtime relationship through which a client receives tag updates. A Vision tag binding creates a subscription, as does an indirect tag binding after its parameters resolve to a tag path. Tags named in a client tag change event are also subscribed.

A scripted read is a request made when the script runs. It does not create the persistent subscription that the reference tracker records. Consequently, a tag can be required by a window yet remain absent from the tracker.

This difference also matters for leased tags: subscriptions trigger their rate changes, while occasional scripted reads do not provide the same native subscription behavior.

Check 1: Classify every discovery method as either subscription tracking or static script review. Expect the tracker column to exclude scripted reads.

Controlled Vision Client Baseline

The tracker identifies subscriptions from a Vision client but does not assign each subscription to a particular window. A controlled baseline supplies that missing attribution by comparing the client before and after opening one target window.

1. Start a dedicated Vision client for the audit so routine operator navigation does not change the subscription set.
2. Close nonessential windows and leave only the resources required to keep the client running.
3. Open the tag reference tracker and record the subscribed tags before loading the target window. This is the baseline set.
4. Record client-level subscriptions separately, especially tags used by client tag change events. They may remain present throughout every window test.

A zero-tag baseline is not required. Startup windows, navigation resources, and client-scoped logic may legitimately hold subscriptions. What matters is a stable, recorded set against which the next capture can be compared.

Check 2: Repeat the baseline capture without opening another window. Expect the same tag set; a changing set means background navigation or client logic is contaminating the test.

Per-Window Subscription Capture

Opening one window causes its direct and indirect bindings to subscribe. The additions relative to the baseline are the window's candidate subscription set. They are candidates because another client resource could subscribe at the same moment.

1. Open one target Vision window and allow its components and bindings to finish loading.
2. Capture the current tracker list.
3. Subtract the baseline set from the current set. Record each added tag against the tested window.
4. Operate selectors, tabs, popups, or other controls that change indirect-binding parameters. Capture the tracker after each reachable state.
5. Close the target window and capture the tracker again. Compare the result with the original baseline.

An indirect binding exposes only the tag path produced by its current parameter values. If an object can point to several assets, units, or tag folders, test every parameter combination that is actually deployed. A single default state cannot inventory the other resolved paths.

If a candidate tag remains subscribed after the window closes, locate the other active client resource that owns the subscription before assigning it to the window. The tracker supplies client-level evidence, not ownership metadata.

Check 3: Reopen the same window in the same state. Expect the same additions to the baseline; missing or extra tags indicate an untested state change or another active subscriber.

Scripted and Indirect Reference Review

Tracker captures must be paired with a static review because scripted reads are invisible to subscription tracking. Review the target window's component event scripts, window-level scripts, and project scripts called from those events. Follow parameters passed into reusable objects instead of stopping at the calling component.

1. Locate each tag-read operation reached from the window.
2. Record literal tag paths directly.
3. For a path built from parameters or string fragments, document the construction rule and the permitted input values.
4. Resolve the constructed path for every deployed parameter set.
5. Trace conditional branches and user actions so reads that occur only during alarms, mode changes, or button actions are included.

A text search can find literal paths and tag-read calls, but it cannot reliably determine every path assembled at runtime. Parameter values provide the missing link. Record both the construction expression and its resolved paths so later cleanup work remains auditable.

Do not convert scripted reads to bindings solely to make them visible in the tracker. Choose a binding when the component needs continuous updates; keep a scripted read when the application needs an explicit read at a defined event. The wrong practice is treating tracker visibility as the design objective.

Check 4: Trigger each scripted action and compare the value returned by the script with the value at its resolved tag path. Expect a successful read from every documented parameter case, even though the tag does not appear as a new tracker subscription.

Tag Disposition Decision

Merge the subscription capture and script review into one dependency register before removing any tag. Absence from the tracker alone is not evidence that a tag is unused.

Use a quarantine or controlled change process for cleanup candidates. Removing many tags at once obscures which deletion caused a broken binding or failed script. Apply changes in reviewable groups and preserve the dependency register with the project change record.

Check 5: For every proposed removal, expect a blank record across window subscriptions, indirect resolutions, scripted reads, and client tag change events. Any populated field blocks removal.

End-to-End Verification

1. Restart or relaunch the controlled Vision client and reproduce the stable baseline.
2. Open each audited window individually. Expect its recorded direct and indirect subscriptions to reappear in the tracker.
3. Exercise every documented indirect-binding state. Expect the active subscription to follow the resolved tag path for that state.
4. Trigger every user action and condition that performs a scripted read. Expect the correct value to reach the component or script result without requiring a tracker entry.
5. Close the window. Expect window-owned subscriptions to leave the active set unless another client resource also uses them.
6. Run the normal navigation sequence after the cleanup change. Expect all displayed values, indirect selections, and scripted actions to behave as recorded.

Check 6: Compare the final tracker captures and script test results with the dependency register. Expect every retained tag to have a recorded subscription or scripted-use path, with no failed binding or read after cleanup.

FAQ