没有不值得去解决的问题,也没有不值得去学习的技术!

Testing Date Archive Pagination: Re-verifying EdgeOne and Cloudflare Query String Normalization

[Figure 3: All four Cloudflare requests were HIT, age continued to increase, but all four raw HTML SHA-256 were different]

作者:

在

,

In the previous article, “From EdgeOne 524 to Query String Normalization“, I documented the process of troubleshooting, adjusting, and verifying the Query String caching strategy for the WordPress Chinese site after it experienced a 524 error under EdgeOne. (Shuijingwanwq.com)

At that time, I had tested various article pages, list pages, and archive pagination, but one scenario remained genuinely uncovered:

Plaintext
/YYYY/MM/DD/page/N/

That is, date archive pagination.

The reason was simple: during testing, I couldn’t find a real, existing date archive that had already generated pagination, so I had to skip it temporarily.

By August 15, 2026, the site had published enough articles that day to finally generate a real, accessible Page 3:

Plaintext
Chinese site:
https://www.shuijingwanwq.com/2026/08/15/page/3/

English site:
https://en.shuijingwanwq.com/2026/08/15/page/3/

I therefore decided to fill in this missing test item.

I originally thought this would be a very simple retest, but an interesting phenomenon occurred again with Cloudflare on the English site:

Cloudflare was clearly hitting the cache, yet the complete HTML SHA-256 returned each time was different.

After further comparing the pages, I ultimately found that the cache itself was fine; the real cause of the hash change was Cloudflare’s dynamic obfuscation of email addresses on the page.

As a result, this retest not only completed the date archive pagination test but also corrected a crucial evaluation method for future CDN cache testing.

Date Archive Page 3 Finally Appears

The Chinese page available for actual testing this time is:

Plaintext
https://www.shuijingwanwq.com/2026/08/15/page/3/

In the browser, you can already see:

Plaintext
Home / 2026 / August / 15 / Page 3

The page title is:

Plaintext
Date: August 15, 2026

Below, articles published earlier that day continue to be listed.

[Figure 1: Date archive Page 3 for August 15, 2026, proving that a real page of the /YYYY/MM/DD/page/N/ type has appeared]
[Figure 1: Date archive Page 3 for August 15, 2026, proving that a real page of the /YYYY/MM/DD/page/N/ type has appeared]

This is exactly the URL type missing from the previous test.

Although other archive pages and pagination had been verified before, from the perspective of CDN cache rules:

Plaintext
/2026/08/15/

and:

Plaintext
/2026/08/15/page/3/

are ultimately two different paths.

Since a real page now exists, there is no need to continue relying on speculation; I can directly perform actual request verification.

Chinese Site EdgeOne: Random Query String Directly Hits Existing Cache

The Chinese site still follows the previous testing approach.

First, request the normal page without parameters:

Plaintext
https://www.shuijingwanwq.com/2026/08/15/page/3/

Then generate a random Query String with the current timestamp that has not been accessed before:

Plaintext
?swq_qs_test=date-page-1786844745

Forming:

Plaintext
https://www.shuijingwanwq.com/2026/08/15/page/3/?swq_qs_test=date-page-1786844745

The test results are straightforward:

Plaintext
========== EdgeOne Date Archive Pagination ==========

HTTP/2 200
eo-cache-status: MISS

--- RANDOM QUERY STRING ---

HTTP/2 200
eo-cache-status: HIT

The first request for the normal URL is:

Plaintext
MISS

But immediately requesting the newly generated random Query String directly yields:

Plaintext
HIT

Further comparing the two HTML files:

Plaintext
b032f39e333db0afe4952b22effcf9955ed1bd4a09076c6fa6a792bf9dc40a39  clean
b032f39e333db0afe4952b22effcf9955ed1bd4a09076c6fa6a792bf9dc40a39  dirty

Ultimately:

Plaintext
same_body=yes
[Figure 2: EdgeOne date archive pagination test, Clean is MISS, random Query String is HIT, both HTML SHA-256 are completely identical]
[Figure 2: EdgeOne date archive pagination test, Clean is MISS, random Query String is HIT, both HTML SHA-256 are completely identical]

This result is sufficient to show that:

EdgeOne did not create a new page cache due to this irrelevant Query String, and date archive pagination can similarly undergo Query String normalization according to the current rules.

Therefore, this item for the Chinese site can be directly judged as passed.

English Site Cloudflare: Random Parameter Also Hits on First Try

Next, testing the English site:

Plaintext
https://en.shuijingwanwq.com/2026/08/15/page/3/

Similarly, first access the normal page, then generate a new random parameter:

Plaintext
?swq_cf_qs_test=date-page-1786844818

During the first test, I got:

Plaintext
CLEAN:

cf-cache-status: HIT
age: 254

Subsequently, request the newly generated random Query String:

Plaintext
DIRTY:

cf-cache-status: HIT
age: 255

This phenomenon itself is already quite valuable.

Because this random parameter was just generated, there was no corresponding access history before.

If Cloudflare treated the full Query String as an independent cache key, then the first access to this random URL would typically be more likely to show a new cache object.

But the actual result was:

Plaintext
HIT

And the cache age went directly from:

Plaintext
254

to:

Plaintext
255

From this, it is clear that the random Query String is continuing to use the existing cache.

But the Complete HTML SHA-256 Is Actually Different

The problem arose during the body comparison.

The first test yielded:

Plaintext
a82d0be563742050ebb8e0595c6182a9a657d0f3d9da831da0081e9d74f1b7b5  clean

e595a892523e343bf52f093cdcc98951e1cc1cb9b770d64c2b4bbe18cba602f8  dirty

same_body=no

That is to say:

Plaintext
Clean SHA-256 != Dirty SHA-256

If following the previous, more direct evaluation method, it would be easy to conclude:

Plaintext
Random Query String
→ Page body has changed
→ Cache normalization might not be actually implemented

But this conclusion clearly contradicts the cache headers.

Because the first access with the random parameter was already:

Plaintext
HIT

And:

Plaintext
age

was still incrementing along the original cache age.

Therefore, I couldn’t draw a conclusion directly based on the full-page SHA-256 here.

First Check if the Same URL is Stable Itself

To rule out the influence of the Query String itself, I conducted another set of control tests:

Plaintext
Clean 1
Clean 2
Dirty 1
Dirty 2

That is:

  • Access the same Clean URL twice consecutively;
  • Access the same Dirty URL twice consecutively.

The cache results were as follows:

Plaintext
age: 341
cf-cache-status: HIT

age: 342
cf-cache-status: HIT

age: 344
cf-cache-status: HIT

age: 345
cf-cache-status: HIT

All four requests:

Plaintext
HIT

The cache age also continued to increase:

Plaintext
341
342
344
345

There was no sign of the Dirty requests rebuilding the cache.

But the raw SHA-256 values below were all different.

[Figure 3: All four Cloudflare requests were HIT, age continued to increase, but all four raw HTML SHA-256 were different]
[Figure 3: All four Cloudflare requests were HIT, age continued to increase, but all four raw HTML SHA-256 were different]

This step actually demonstrated that:

The problem could not be simply attributed to the Query String.

Because even:

Plaintext
Clean 1

and:

Plaintext
Clean 2

these two completely identical URLs returned different HTML SHA-256 values.

The comparison results were:

Plaintext
clean1_vs_clean2=different
dirty1_vs_dirty2=different
clean_vs_dirty=different

This meant that during the process of Cloudflare returning the HTML, some dynamic content was changing.

Directly Comparing HTML, Finally Finding the Only Difference

Continuing to compare:

Plaintext
Clean 1

and:

Plaintext
Clean 2

line by line, I finally found the actual change.

In the first response, part of the Mail social link at the bottom of the page was:

HTML
href="/cdn-cgi/l/email-protection#0e7d667b6764676069796f60797f4e69636f6762206d6163"

In the second response, it became:

HTML
href="/cdn-cgi/l/email-protection#1a69726f737073747d6d7b746d6b5a7d777b737634797577"

The rest of the page content had not changed.

The difference was concentrated in:

Plaintext
/cdn-cgi/l/email-protection#...

here.

At this point, the problem became quite clear.

There was an email link at the bottom of the page, and after being returned through Cloudflare, the email address was rewritten into:

Plaintext
/cdn-cgi/l/email-protection#...

format.

This protection value changes, so even if:

  • The WordPress page content hasn’t changed;
  • The article list hasn’t changed;
  • The pagination hasn’t changed;
  • Cloudflare is still hitting the existing cache;

The HTML ultimately sent to the client could still differ by a few bytes.

And SHA-256 is sensitive to any single byte change.

So the previous:

Plaintext
same_body=no

did not indicate a problem with the Cloudflare cache.

Normalizing Cloudflare’s Dynamic Email Protection Value

For final confirmation, I performed one more processing step.

Before calculating the SHA-256, I only replaced:

Plaintext
The dynamic value after /cdn-cgi/l/email-protection#

uniformly with:

Plaintext
/cdn-cgi/l/email-protection#NORMALIZED

leaving the rest of the HTML untouched by even a single byte.

Then recalculated:

Plaintext
Clean 1
Clean 2
Dirty 1
Dirty 2

the SHA-256 for the four pages.

The final results:

Plaintext
clean1  7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf

clean2  7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf

dirty1  7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf

dirty2  7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf

All four were completely identical.

The final comparison:

Plaintext
clean1_vs_clean2 = same
dirty1_vs_dirty2 = same
clean_vs_dirty   = same
[Figure 4: After normalizing the Cloudflare email protection value, the Clean and Dirty HTML SHA-256 for all four files are completely identical]

At this point, the entire issue was completely resolved.

English Site Cloudflare Also Passes

Based on all the evidence, the date archive pagination for the English site can ultimately also be judged as passed.

Test URL:

Plaintext
https://en.shuijingwanwq.com/2026/08/15/page/3/

First access with a random Query String:

Plaintext
cf-cache-status: HIT

Cache age increased continuously:

Plaintext
341
342
344
345

This indicates that the random Query String did not obviously create a new independent cache object.

The initially observed:

Plaintext
Clean SHA-256 != Dirty SHA-256

was further proven not to be caused by the Query String.

Because the completely identical:

Plaintext
Clean 1
Clean 2

raw HTML was also different.

Finally, after normalizing:

Plaintext
/cdn-cgi/l/email-protection#...

this Cloudflare dynamic field:

Plaintext
Clean 1 = Clean 2 = Dirty 1 = Dirty 2

Therefore, the final conclusion is:

Cloudflare’s Query String normalization for date archive pagination is also working normally.

Final Test Results for Both CDNs

This retest can be briefly summarized into the following two sets of results.

Chinese site EdgeOne:

Plaintext
URL:
/2026/08/15/page/3/

HTTP:
200

Clean:
MISS

Random Query String:
HIT

Raw HTML:
SHA-256 identical

same_body:
yes

Result:
Pass

English site Cloudflare:

Plaintext
URL:
/2026/08/15/page/3/

HTTP:
200

Clean:
HIT

Random Query String first access:
HIT

Cache age:
Continuously increasing

Raw HTML:
Dynamic differences exist

Source of difference:
/cdn-cgi/l/email-protection#...

After normalizing Cloudflare dynamic field:
Clean 1 = Clean 2 = Dirty 1 = Dirty 2

Result:
Pass

At this point, the previously uncovered:

Plaintext
/YYYY/MM/DD/page/N/

date archive pagination has been officially retested and completed.

The Truly Noteworthy Change This Time is the Testing Method

Initially, I just wanted to fill in the missing date archive pagination test.

But the most valuable takeaway this time was not the date pagination itself, but rather the further confirmation that:

The raw SHA-256 of the complete HTML cannot be used as an absolute criterion for page cache consistency in all CDN scenarios.

The Chinese site EdgeOne was very straightforward this time:

Plaintext
Clean SHA-256 = Dirty SHA-256

So I could directly determine that the content was consistent.

But for the English site through Cloudflare, the situation was different.

Cloudflare might also perform dynamic processing on certain HTML content during the process of returning the cache object to the browser.

This time, I actually encountered:

Plaintext
/cdn-cgi/l/email-protection#...

changing every time.

This difference does not mean that:

  • WordPress generated different pages;
  • The Query String caused different pages;
  • Cloudflare created different caches;
  • The cache rules failed.

It merely indicates that:

The HTML the client ultimately receives may also contain dynamic fields generated by the CDN itself.

How to Test Query String Caching in the Future

After this verification, I will adjust the evaluation order when testing similar issues in the future.

First, check:

Plaintext
HTTP status

to confirm that the page itself is accessible normally.

Then check the CDN’s cache status, for example:

Plaintext
eo-cache-status

or:

Plaintext
cf-cache-status

Next, observe whether the first request with a random Query String results in:

Plaintext
MISS

or:

Plaintext
HIT

For Cloudflare, you can also continue to combine it with:

Plaintext
age

to determine whether it is reusing an existing cache object.

If body-level confirmation is still needed, then compare the HTML.

However, if the raw SHA-256 does not match, I will no longer immediately conclude:

Plaintext
Cache failure

Instead, I will first check:

Plaintext
Whether consecutive requests to the same Clean URL also differ

If the same URL is not stable itself, then continue to locate the dynamic field.

Finally, after normalizing the dynamic fields that clearly belong to the CDN’s own response processing and are unrelated to the business page content, perform the real body hash comparison.

Compared to simply using:

Plaintext
same_body=yes/no

this method is clearly more reliable.

Summary

The date archive pagination test gap left by the previous article, “From EdgeOne 524 to Query String Normalization“, has finally been filled this time.

The actual test page was:

Plaintext
/2026/08/15/page/3/

For the Chinese site EdgeOne:

Plaintext
Clean:MISS
Dirty:HIT
same_body=yes

Date archive pagination Query String normalization is working normally.

For the English site Cloudflare, the first access with a random Query String also directly resulted in:

Plaintext
HIT

The cache age continued to increase.

Although the raw HTML SHA-256 were all different at first, a line-by-line comparison ultimately confirmed that the only difference came from:

Plaintext
/cdn-cgi/l/email-protection#...

After normalizing this Cloudflare dynamic field:

Plaintext
Clean 1
Clean 2
Dirty 1
Dirty 2

The SHA-256 of all four HTML files were completely identical.

Therefore, it can be finally confirmed that:

Both EdgeOne and Cloudflare’s Query String normalization for WordPress date archive pagination are working normally.

And this test also further refined the methodology for subsequent CDN verification:

First check the cache status and cache age, then determine whether the random parameter hits the existing cache; when body comparison is needed, you must also first rule out the CDN’s own dynamic response rewriting, and you cannot judge a cache anomaly solely based on a different full-page raw SHA-256.

关于作者 · 持续学习与技术实践

我是一名拥有 15 年以上开发经验的技术从业者,自 2013 年起持续运营个人技术博客,记录工作与个人项目中遇到的真实问题,以及解决问题过程中的探索、实践和思考。

除了技术写作,我也在持续开发和维护自己的独立项目,探索新技术和新工具在实际场景中的应用。我始终相信,没有不值得去解决的问题,也没有不值得去学习的技术。

如果这篇文章对你有所帮助,欢迎浏览博客中的其他文章,也欢迎交流技术经验与想法。

关于我  ·  GitHub  ·  邮件联系