private string ParsePartialSuccessResponse(Transmission initialTransmission, TransmissionProcessedEventArgs args, out int lastStatusCode)
        {
            BackendResponse backendResponse = null;

            lastStatusCode = 206;

            if (args != null && args.Response != null)
            {
                backendResponse = this.backoffLogicManager.GetBackendResponse(args.Response.Content);
            }

            if (backendResponse == null)
            {
                return(null);
            }

            string newTransmissions = null;

            if (backendResponse.ItemsAccepted != backendResponse.ItemsReceived)
            {
                string[] items = JsonSerializer
                                 .Deserialize(initialTransmission.Content)
                                 .Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

                foreach (var error in backendResponse.Errors)
                {
                    if (error != null)
                    {
                        if (error.Index >= items.Length || error.Index < 0)
                        {
                            TelemetryChannelEventSource.Log.UnexpectedBreezeResponseWarning(items.Length, error.Index);
                            continue;
                        }

                        TelemetryChannelEventSource.Log.ItemRejectedByEndpointWarning(error.Message);

                        if (error.StatusCode == ResponseStatusCodes.RequestTimeout ||
                            error.StatusCode == ResponseStatusCodes.ServiceUnavailable ||
                            error.StatusCode == ResponseStatusCodes.InternalServerError ||
                            error.StatusCode == ResponseStatusCodes.ResponseCodeTooManyRequests ||
                            error.StatusCode == ResponseStatusCodes.ResponseCodeTooManyRequestsOverExtendedTime)
                        {
                            if (string.IsNullOrEmpty(newTransmissions))
                            {
                                newTransmissions = items[error.Index];
                            }
                            else
                            {
                                newTransmissions += Environment.NewLine + items[error.Index];
                            }

                            // Last status code is used for tracing purposes. We will get only one out of many. Most likely they all will be the same.
                            lastStatusCode = error.StatusCode;
                        }
                    }
                }
            }

            return(newTransmissions);
        }
 private static void AdditionalVerboseTracing(string httpResponse)
 {
     // For perf reason deserialize the response only when verbose tracing is enabled
     if (TelemetryChannelEventSource.IsVerboseEnabled && httpResponse != null)
     {
         try
         {
             BackendResponse backendResponse = BackoffLogicManager.GetBackendResponse(httpResponse);
             if (backendResponse != null && backendResponse.Errors != null)
             {
                 foreach (var error in backendResponse.Errors)
                 {
                     if (error != null)
                     {
                         TelemetryChannelEventSource.Log.ItemRejectedByEndpointWarning(error.Message);
                     }
                 }
             }
         }
         catch (Exception)
         {
             // This code is for tracing purposes only; it cannot not throw
         }
     }
 }
        private void AdditionalVerboseTracing(HttpWebResponse httpResponse)
        {
            // For perf reason deserialize only when verbose tracing is enabled
            if (TelemetryChannelEventSource.Log.IsVerboseEnabled && httpResponse != null)
            {
                try
                {
                    var stream = httpResponse.GetResponseStream();
                    if (stream != null)
                    {
                        using (StreamReader content = new StreamReader(stream))
                        {
                            string response = content.ReadToEnd();

                            if (!string.IsNullOrEmpty(response))
                            {
                                BackendResponse backendResponse = this.backoffLogicManager.GetBackendResponse(response);

                                if (backendResponse != null && backendResponse.Errors != null)
                                {
                                    foreach (var error in backendResponse.Errors)
                                    {
                                        if (error != null)
                                        {
                                            TelemetryChannelEventSource.Log.ItemRejectedByEndpointWarning(error.Message);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception)
                {
                    // This code is for tracing purposes only; it cannot not throw
                }
            }
        }