[Docs] Fix the policywrap sample

[peter-csala]

Pull Request

The issue or feature being addressed

• Retry and Rate Limit chaining #1718

Details on the issue fix or feature implementation

• V7's sample code created a policy chain where the timeout was the outer and the retry was the inner
• Fixed the V7's sample code to have the same behavior as V8's sample
• Also extended the comment to further clarify which one is the outer and which one is the inner

Confirm the following

• I started this PR by branching from the head of the default branch
• I have targeted the PR to merge into the default branch
• I have included unit tests for the issue/feature
• I have successfully run a local build

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Comparison is base (00cd051) 84.56% compared to head (c47d833) 84.56%.

Additional details and impacted files

@@           Coverage Diff           @@
##             main    #1728   +/-   ##
=======================================
  Coverage   84.56%   84.56%           
=======================================
  Files         307      307           
  Lines        6790     6790           
  Branches     1043     1043           
=======================================
  Hits         5742     5742           
  Misses        839      839           
  Partials      209      209           

Flag	Coverage Δ
linux	84.56% <ø> (ø)
macos	84.56% <ø> (ø)
windows	84.56% <ø> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[peter-csala]

@martintmk In case of V8 the FIFO statement is incorrect IMHO. The firstly added strategy will be executed last.

So, first you define the outer most and last the inner most.

Which is the same order as in case of V7 (first parameter is the outer most, last parameter is the inner most).

If you agree then I will update this section to reflect the current behavior.

Dotnet fiddle: https://dotnetfiddle.net/znmcPA

[martintmk]

@martintmk In case of V8 the FIFO statement is incorrect IMHO. The firstly added strategy will be executed last.

So, first you define the outer most and last the inner most.

Which is the same order as in case of V7 (first parameter is the outer most, last parameter is the inner most).

If you agree then I will update this section to reflect the current behavior.

Dotnet fiddle: https://dotnetfiddle.net/znmcPA

They problem is relying on the callback events, what's important is the when retry strategy starts executing and when it ends. Yes, it's true that the timeout event is reported first, but at that point the retry strategy is already executing.

If you put custom strategy that just reports events before and after the callback is executed, it would become clear.

[peter-csala]

They problem is relying on the callback events, what's important is the when retry strategy starts executing and when it ends. Yes, it's true that the timeout event is reported first, but at that point the retry strategy is already executing.

If you put custom strategy that just reports events before and after the callback is executed, it would become clear.

Sorry @martintmk , but I'm a bit lost. Could you please rephrase your statement? (I'm not sure I understand it 100%).

[martintmk]

They problem is relying on the callback events, what's important is the when retry strategy starts executing and when it ends. Yes, it's true that the timeout event is reported first, but at that point the retry strategy is already executing.
If you put custom strategy that just reports events before and after the callback is executed, it would become clear.

Sorry @martintmk , but I'm a bit lost. Could you please rephrase your statement? (I'm not sure I understand it 100%).

I believe this test conveys what I am trying to say. It adds multiple strategies to the pipeline and asserts the order of execution:

Polly/test/Polly.Core.Tests/ResiliencePipelineBuilderTests.cs

Line 64 in 41d4e8d

public void AddPipeline_Multiple_Ok()

[peter-csala]

ResiliencePipelineBuilderTests.cs

I understand that

• in case of Before the order is from outer to inner and
• in case of After the order is from inner to outer.

(sequence diagram)

---

I think I get it what do you want to describe.

Forgot the onRetry and onTimeout delegates and let's focus on this example:

var retryPolicy = Policy.Handle<Exception>().WaitAndRetryAsync(2, _ => TimeSpan.FromSeconds(0.5));
var timeoutPolicy = Policy.TimeoutAsync(TimeSpan.FromSeconds(1));

var wrappedPolicy = Policy.WrapAsync(retryPolicy, timeoutPolicy);

Console.WriteLine("Outer: " + wrappedPolicy.Outer.GetType().Name);
Console.WriteLine("Inner: " + wrappedPolicy.Inner.GetType().Name);

and the output:

Outer: AsyncRetryPolicy
Inner: AsyncTimeoutPolicy

are you convinced ?