算法-跟踪从一项服务到另一项服务的数据延迟

Question

Say I subscribe to a service that gives me the temperature in my city and it sends data ticks sometimes really fast, sometimes in longer intervals.

Temp Timestamp (ms)
20C 1
21C 2
20C 286
21C 287
21C 288
21C 289
20C 423
etc.

Now lets say the subscriber service converts to Fahrenheit and republishes this data within my company, with it's own timestamp of when it does so.

Caveat 1: Some ticks of data are dropped because some of the ticks come in faster than can be recalculated to Fahrenheit, so it will take the latest value in the Queue.

Caveat 2: The Fahrenheit data published may take "longer" (ie. have higher latency) if a lot of ticks come in reducing available bandwidth.

Temp Timestamp (ms)
68F 2:00:00:0001
69F 2:00:00:0023
68F 2:00:00:0063
etc..

---

What would be the best way to "match" the possible corresponding ticks and calculate a latency between the two services? Would it be better to report two latencies? One during high load and one during standard load? If so, how do I determine when high load is? When some latency values are certain std deviations away?

Answer 1

You have a Celsius service C, a Fahrenheit service F, and a Fahrenheit subscriber S.

There are three places you can measure latency:

C--->F (The time it takes for outbound C to go to F)
F--->S (The time it takes for outbound F to go to S)
F(c)   (The time of computation for Celsius to Fahrenheit).

If you timestamp all outbound traffic, whether outbound of C or F, you can measure service latency from the consumer's perspective simply by comparing the timestamp to the current time and getting the latency. There are similar methods to compute latency within F.

Regarding your two caveats:

1. If data is lost, it does not have latency. It never reached the end, so you can't measure difference between beginning and end times.

2. It's normal to have higher latency when there's increased usage. Report it as you usually would, no need for special handling.

You should be able to figure out when "high load" is if you report your average latencies at regular intervals. You can create a time-series graph, and it should show a bump in latency when there are more connections.