IMD SolutionComputing LibraryShop main store

Troubleshooting

Diagnose a slow historian web client page load on the server

Edge computing and IIoT Published 8 min read

Short answer

Capture the load in the browser Network tab with the cache disabled and split each slow request into connection, TLS, waiting and download phases. When waiting for server response holds most of the time, the historian web services are waiting on the shared SQL Server host: cap Max server memory, check disk latency, then send support a redacted HAR. The timing split, not the total load time, decides the cause.

On this page
  1. What is the browser actually waiting on when the web client loads?
  2. How do I capture a clean network baseline in Edge?
  3. How do I split the load time into phases that point at a cause?
  4. Why would the SSL phase be slow on a localhost connection?
  5. What do I check on the server when waiting for server response dominates?
  6. What do I send the vendor when the page is still slow?
  7. How do I prove the load time is fixed?
  8. Questions asked

A historian web client that needs tens of seconds before it is usable is diagnosed by splitting the wait into phases, not by chasing the total. Open the page in Edge DevTools with the Network tab recording and the cache disabled, read the Timing pane on the slowest requests, and fix the phase that owns the largest share. In the reported environment that matches this pattern — historian 2023 R2 on Windows Server 2022 with SQL Server 2022 Standard, opened on the server at https://localhost:32573 in Edge build 131.0.2903.70 — the background data calls returned slower than on a basic reference VM, which points the work at the shared host rather than the browser.

What is the browser actually waiting on when the web client loads? #

The screen is ready only when the page shell plus the data calls behind it have returned, so the wait splits into four measurable phases: connection, TLS, waiting for server response, and content download.

The first request returns the shell and its script bundles. The client then issues XHR calls to the historian web services for configuration, tag lists and session data, and each of those calls reaches SQL Server or the historian storage engine. A call can run in the background and still sit on the critical path of a usable screen, because the data areas fill only when their calls return. How fast the historian hands data back once a request reaches the storage engine is its own question, covered in historian data retrieval speed: what actually decides it.

What you see Where the time is DevTools evidence
Nothing paints for a long time Shell and bundle delivery, TLS, the browser Long bars on the document and script requests
Shell paints, data areas stay empty Back-end XHR calls Long waiting for server response on API calls
Slow only on the server, fast from a workstation Host load, local security software, browser profile Same requests, different timings per client

The decision at this step: capture before changing anything, because each row of that table leads to different work.

How do I capture a clean network baseline in Edge? #

Press F12, open the Network tab, enable Preserve log and Disable cache, load the client once through to a usable screen, then sort by Time and filter to Fetch/XHR — that capture is your baseline.

  1. Enable Preserve log and Disable cache so every cold load is comparable.
  2. Load the client — in the example environment, https://localhost:32573 — and wait until the UI is usable.
  3. Sort by Time descending, filter to Fetch/XHR, and write down the five slowest requests with their URLs and durations.
  4. Open the Timing pane on each of the five and record the split: queueing/stalled, DNS, initial connection, SSL, waiting for server response (TTFB), and content download.
  5. Reload once with the cache still disabled and keep the run whose slow set repeats.

Repeat the capture once from a workstation using the server's host name, so server-side delay can be separated from local-browser delay. The decision: you now hold a per-request table with a dominant phase on each slow call, and every step after this targets one of those phases.

How do I split the load time into phases that point at a cause? #

Add up waiting for server response across the five slowest calls, divide by the total time to a usable screen, and if that share sits at or above 50 percent, the back end owns the delay — work the host, not the browser.

Read the shares against this rule:

  • Waiting at or above 50 percent — back-end path: the host checks in the next sections.
  • SSL plus connection the largest share — certificate validation path.
  • Content download the largest share — payload: read the Size column and cut what the calls return.
  • Queueing or stalled the largest share — browser side: repeat in an InPrivate window with extensions off.

Illustrative capture, an example rather than a measured result from your system, for a load on the host itself:

  • Time from first request to usable UI: 11.9 s.
  • Document request: 0.2 s queueing + 0.05 s SSL + 0.3 s waiting + 0.4 s download = 0.95 s.
  • Five slowest XHR calls, waiting for server response: 3.1 + 2.3 + 1.8 + 1.4 + 1.0 = 9.6 s; their connection, TLS and download phases together: 0.3 s.
  • Remainder, browser script and render: 11.9 − 0.95 − 9.6 − 0.3 = 1.05 s.

Waiting share: 9.6 s ÷ 11.9 s = 0.807, or 80.7 percent of the load. The decision for this capture: a back-end case on the first test — go straight to the host checks and spend nothing on browser-side changes.

Why would the SSL phase be slow on a localhost connection? #

On a loopback connection, DNS, initial connection and SSL should each read a few milliseconds, so an SSL phase approaching a second on the server itself means certificate validation is stalling, not the historian.

The mechanism is documented for Wonderware Historian Client controls used in InTouch: the software attempts to verify the server's SSL certificate, cannot reach the revocation endpoint over the network, and waits out the timeout. A server-class host with no outbound internet access is the classic case. Inspect the certificate bound to the port the client URL uses, and check whether the CRL or OCSP addresses it lists resolve and answer from that host. The fix is reachability — let the host fetch those endpoints, or bind a certificate whose revocation endpoints the host can reach — decided under your security policy rather than by turning revocation checking off plant-wide. Confirm by comparing the same timing columns from a workstation. The decision: if SSL on the loopback load reads milliseconds, TLS is cleared and the wait lives further down the phase list.

What do I check on the server when waiting for server response dominates? #

Work three things in order while reloading the page: SQL Server memory pressure first, disk latency on the SQL volumes second, endpoint protection third — one change at a time, re-measuring after each.

The web services are waiting on their own dependencies. In the reported environment the historian services and SQL Server share one Windows host, so they compete for memory and disk.

  1. Memory. Open Task Manager during a cold load and note which process holds the RAM, sqlservr.exe or a historian service. Then read Max server memory (MB) in SQL Server Management Studio under Server Properties, Memory. An instance left uncapped claims most of the host's RAM and pages the historian services. Illustrative sizing on a 32 GB host: 32 GB − 4 GB for Windows − 4 GB for the historian services = 24 GB for Max server memory (MB). Set it and reload.
  2. Disk. In Resource Monitor during the load, watch the queue and the response time on the SQL data and log volumes, and compare them with the same counters at idle. Response time that climbs well above its idle value while the slow calls run extends every call that touches the database; the decision is to move the SQL data and log files onto their own volume or faster storage.
  3. Endpoint protection. A documented case outside web clients: Windows Defender platform update 1.421.1630.0 slowed launching of the Ignition Designer, a different automation client. Check whether on-access scanning covers the historian web folders and the browser cache on the server, and test only with exclusions your security policy documents.
  4. The browser on the server. Press Shift+Esc to open the Edge browser task manager and confirm the tab is not CPU-bound locally.

If the memory cap and the storage change leave the waiting times untouched and the box is undersized for both roles, the remaining move is the hardware itself: an industrial mini PC sized for the combined load replaces the host. The decision after each change: reload with the cache disabled and see which call in the baseline table shrank.

What do I send the vendor when the page is still slow? #

Send a redacted HAR file, the exact version set, and your per-request timing table — that package answers in one pass what a description of slow cannot.

  • A .har file from a short session, saved with the export control in the Network tab. Redact cookies, authorization headers and tokens before it leaves your network, because the file stores them exactly as the browser sent them; treat the capture as a credential.
  • The version set: historian release with its patch or service pack level, the OS, the SQL Server edition, and the browser build — the same four facts the example environment recorded.
  • The per-request timing table, with the dominant phase marked on each slow call.
  • The same capture from a workstation, so server-side delay is separable from local-browser delay.

Calls that fail outright instead of finishing late are a connection fault, not a performance one — the steps for those are in troubleshooting historian trend client connection failures. The decision: the package goes out only when the capture covers a complete load, first request to usable UI, and shows the same slow requests your table lists.

How do I prove the load time is fixed? #

Reload three times with the cache disabled — once right after a service restart and twice warm — and confirm the five slowest calls hold their new, shorter durations on every run and from a workstation as well.

  1. Close all Edge windows, reopen, and load the client with Disable cache still on.
  2. Export a new HAR and compare the five slowest requests against the baseline table.
  3. Run the three reloads and record the durations each time.
  4. Confirm the UI turns usable at the moment the last blocking call returns, with nothing left pending in the Network tab.

At the example's numbers the target is concrete: cutting 8 s from 9.6 s of waiting leaves 1.6 s, and the load lands at 11.9 − 8 = 3.9 s with every other phase unchanged, a waiting share of 1.6 ÷ 3.9 = 41 percent, under the rule. The decision: fixed means the same request set, a shorter waiting phase, and numbers that repeat across runs and across clients.

Questions asked

Why measure XHR calls that run in the background?

They do not block the shell from painting, but the screen is only usable once the data calls it depends on have returned, and those are the calls that reach the historian web services and the database. A background call can still own most of the total wait, which is why the slow set is measured, not skipped.

What do I strip out of a HAR file before sending it?

Cookies, authorization headers and session tokens, in that order of risk, because the file records them exactly as the browser sent them. Open the .har in a text editor, delete those values, and keep the captured session short so there is less to redact in the first place.

How much memory should SQL Server get on a host it shares with the historian?

Total RAM minus the operating system minus the historian services. On a 32 GB host that is 32 minus 4 minus 4, so 24 GB set as Max server memory (MB). An uncapped instance takes most of the RAM, pages the historian services, and stretches every data call.

Is a slow first load after a service restart a fault?

No. One slow cold load followed by fast warm loads is cache and service warm-up. Open a support case only when three cold loads with the cache disabled repeat the same slow request set, because repeatability across cold loads is the fault signal and a single long load is not.

Keep reading

  • 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

  • Troubleshooting

    Fix InTouch 2023 Test Connection failure to Historian

    Test Connection from InTouch 2023 to a remote Historian fails for two reasons: the Historian node's firewall blocks the SQL Server listener even though ping works, and the Distributed Name Manager history provider does not support Windows credentials. Prove TCP reachability, then use a SQL Server login stored in Credentials Manager.

    Edge computing and IIoT

  • 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

Why historian backfill runs slow from Tier 1 to Tier 2