API速率限制器间歇性悬挂

Question

我写了一个简单的(我认为...)速率限制器,以将事件驱动系统保持在我们的许可API命中限制之下.出于某种原因,有时会在发送400-500个请求后将其占用.

我最好的想法是我搞砸了等待函数,所以在某些情况下它永远不会返回,但我无法找到有缺陷的逻辑.另一个想法是我拙劣的异步/任务互操作导致问题.它总是先工作然后再工作.ApiRateLimiter在多个组件之间共享一个实例,以便在系统范围内实现命中限制.

type RequestWithReplyChannel = RequestWithKey * AsyncReplyChannel<ResponseWithKey>

type public ApiRateLimiter(httpClient: HttpClient, limitTimePeriod: TimeSpan, limitCount: int) =

let requestLimit = Math.Max(limitCount,1)

let agent = MailboxProcessor<RequestWithReplyChannel>.Start(fun inbox -> 

    let rec waitUntilUnderLimit (recentRequestsTimeSent: seq<DateTimeOffset>) = async{
        let cutoffTime = DateTimeOffset.UtcNow.Subtract limitTimePeriod
        let requestsWithinLimit = 
            recentRequestsTimeSent 
            |> Seq.filter(fun x -> x >= cutoffTime)
            |> Seq.toList

        if requestsWithinLimit.Length >= requestLimit then
            let! _ = Async.Sleep 100 //sleep for 100 milliseconds and check request limit again
            return! waitUntilUnderLimit requestsWithinLimit
        else
            return requestsWithinLimit
    }

    let rec messageLoop (mostRecentRequestsTimeSent: seq<DateTimeOffset>) = async{
        // read a message
        let! keyedRequest,replyChannel = inbox.Receive()
        // wait until we are under our rate limit
        let! remainingRecentRequests = waitUntilUnderLimit mostRecentRequestsTimeSent

        let rightNow = DateTimeOffset.UtcNow

        let! response =
            keyedRequest.Request
            |> httpClient.SendAsync
            |> Async.AwaitTask

        replyChannel.Reply { Key = keyedRequest.Key; Response = response }

        return! messageLoop (seq {
            yield rightNow
            yield! remainingRecentRequests
        })
    }

    // start the loop
    messageLoop (Seq.empty<DateTimeOffset>)
)            

member this.QueueApiRequest keyedRequest =
    async {
        return! agent.PostAndAsyncReply(fun replyChannel -> (keyedRequest,replyChannel))
    } |> Async.StartAsTask

有些请求很大,需要花费一点时间,但是没有什么可以导致请求发送完全死亡,我看到这个东西.

谢谢你花点时间看看!

Answer 1

我注意到您正在使用 seq 建立最近发送请求的列表：

seq {
    yield rightNow
    yield! remainingRecentRequests
}

由于 F# 序列是惰性的，因此会生成一个枚举器，当询问其下一个值时，该枚举器将首先生成一个值，然后开始迭代其子 seq 并生成一个值。每次产生新的请求时，都会添加一个新的枚举器——但是旧的枚举器什么时候被处理掉呢？您可能会认为一旦它们过期，即一旦Seq.filterinwaitUntilUnderLimit返回 false，它们就会被处理掉。但想一想：F# 编译器如何知道过滤条件一旦为 false 一次就始终为 false？如果没有深入的代码分析（编译器不会这样做），它就不能。因此，“旧”的 seq 永远不会被垃圾收集，因为它们仍然被保留以备不时之需。我不能 100% 确定这一点，因为我还没有测量代码的内存使用情况，但如果您要测量实例的内存使用情况，ApiRateLimiter我打赌您会看到它稳步增长而不会下降。

我还注意到您正在将新项目添加到序列的前面。这与 F# 列表使用的语义完全相同，但对于列表，没有可分配的 IEnumerable 对象，并且一旦列表项不满足条件List.filter，它将被丢弃。因此，我重写了您的代码以使用最近时间列表而不是 seq，并且为了提高效率我还进行了另一项更改：因为您创建列表的方式保证了它将被排序，最近的事件在前，最旧的在最后，我替换List.filter为List.takeWhile。这样，当第一个日期早于截止日期的那一刻，它将停止检查较旧的日期。

通过此更改，您现在应该拥有实际到期的旧日期，并且您的类的内存使用量ApiRateLimiter应该波动但保持不变。（每次调用都会创建新列表waitUntilUnderLimit，因此会产生一些 GC 压力，但这些都应该在第 0 代）。我不知道这是否能解决您的挂起问题，但这是我在您的代码中看到的唯一问题。

顺便说一句，我也let! _ = Async.Sleep 100用替换了你的行do! Async.Sleep 100，这更简单。这里没有效率提升，但是没有必要使用let! _ =等待返回Async<unit>；这正是do!关键字的用途。

type RequestWithReplyChannel = RequestWithKey * AsyncReplyChannel<ResponseWithKey>

type public ApiRateLimiter(httpClient: HttpClient, limitTimePeriod: TimeSpan, limitCount: int) =

    let requestLimit = Math.Max(limitCount,1)

    let agent = MailboxProcessor<RequestWithReplyChannel>.Start(fun inbox -> 

        let rec waitUntilUnderLimit (recentRequestsTimeSent: DateTimeOffset list) = async{
            let cutoffTime = DateTimeOffset.UtcNow.Subtract limitTimePeriod
            let requestsWithinLimit = 
                recentRequestsTimeSent 
                |> List.takeWhile (fun x -> x >= cutoffTime)

            if List.length requestsWithinLimit >= requestLimit then
                do! Async.Sleep 100 //sleep for 100 milliseconds and check request limit again
                return! waitUntilUnderLimit requestsWithinLimit
            else
                return requestsWithinLimit
        }

        let rec messageLoop (mostRecentRequestsTimeSent: DateTimeOffset list) = async{
            // read a message
            let! keyedRequest,replyChannel = inbox.Receive()
            // wait until we are under our rate limit
            let! remainingRecentRequests = waitUntilUnderLimit mostRecentRequestsTimeSent

            let rightNow = DateTimeOffset.UtcNow

            let! response =
                keyedRequest.Request
                |> httpClient.SendAsync
                |> Async.AwaitTask

            replyChannel.Reply { Key = keyedRequest.Key; Response = response }

            return! messageLoop (rightNow :: remainingRecentRequests)
        }

        // start the loop
        messageLoop []
    )            

    member this.QueueApiRequest keyedRequest =
        async {
            return! agent.PostAndAsyncReply(fun replyChannel -> (keyedRequest,replyChannel))
        } |> Async.StartAsTask