/// <summary>
        /// Processes the queues.
        /// </summary>
        /// <param name="tokenMetadata">The token metadata.</param>
        private void ProcessQueues(AccessTokenQueuesMetadata tokenMetadata)
        {
            foreach (var queue in tokenMetadata.Queues)
            {
                if (DateTimeOffset.Now >= queue.NextDequeueTime)
                {
                    RollbarResponse response      = null;
                    PayloadBundle   payloadBundle = Process(queue, out response);
                    if (payloadBundle == null || response == null)
                    {
                        continue;
                    }

                    switch (response.Error)
                    {
                    case (int)RollbarApiErrorEventArgs.RollbarError.None:
                        payloadBundle.Signal?.Release();
                        queue.Dequeue();
                        tokenMetadata.ResetTokenUsageDelay();
                        break;

                    case (int)RollbarApiErrorEventArgs.RollbarError.TooManyRequests:
                        ObeyPayloadTimeout(payloadBundle, queue);
                        tokenMetadata.IncrementTokenUsageDelay();
                        this.OnRollbarEvent(
                            new RollbarApiErrorEventArgs(queue.Logger, payloadBundle.GetPayload(), response)
                            );
                        return;

                    default:
                        ObeyPayloadTimeout(payloadBundle, queue);
                        this.OnRollbarEvent(
                            new RollbarApiErrorEventArgs(queue.Logger, payloadBundle.GetPayload(), response)
                            );
                        break;
                    }
                }
            }

            // let's see if we can unregister any recently released queues:
            var releasedQueuesToRemove = tokenMetadata.Queues.Where(q => q.IsReleased && (q.GetPayloadCount() == 0)).ToArray();

            if (releasedQueuesToRemove != null && releasedQueuesToRemove.LongLength > 0)
            {
                foreach (var queue in releasedQueuesToRemove)
                {
                    this.Unregister(queue);
                }
            }
        }
        private void ProcessQueues(AccessTokenQueuesMetadata tokenMetadata)
        {
            foreach (var queue in tokenMetadata.Queues)
            {
                if (DateTimeOffset.Now >= queue.NextDequeueTime)
                {
                    Payload payload = queue.Peek();
                    if (payload == null)
                    {
                        continue;
                    }

                    var response = Process(payload, queue.Logger.Config);
                    if (response == null)
                    {
                        continue;
                    }

                    switch (response.Error)
                    {
                    case (int)RollbarApiErrorEventArgs.RollbarError.None:
                        payload.Signal?.Release();
                        queue.Dequeue();
                        tokenMetadata.ResetTokenUsageDelay();
                        break;

                    case (int)RollbarApiErrorEventArgs.RollbarError.TooManyRequests:
                        ObeyPayloadTimeout(payload, queue);
                        tokenMetadata.IncrementTokenUsageDelay();
                        this.OnRollbarEvent(
                            new RollbarApiErrorEventArgs(queue.Logger.Config, payload, response)
                            );
                        return;

                    default:
                        ObeyPayloadTimeout(payload, queue);
                        this.OnRollbarEvent(
                            new RollbarApiErrorEventArgs(queue.Logger.Config, payload, response)
                            );
                        break;
                    }
                }
            }
        }