public async Task DatadogHttpClient_WhenOnlyPartOfResponseIsAvailable_ParsesCorrectly(int bytesToRead)
{
var client = DatadogHttpClient.CreateTraceAgentClient();
var requestContent = new BufferContent(new ArraySegment <byte>(new byte[0]));
var htmlResponse = string.Join("\r\n", HtmlResponseLines());
using var requestStream = new MemoryStream();
var responseBytes = Encoding.UTF8.GetBytes(htmlResponse);
using var responseStream = new RegulatedStream(responseBytes, bytesToRead);
var request = new HttpRequest("POST", "localhost", string.Empty, new HttpHeaders(), requestContent);
var response = await client.SendAsync(request, requestStream, responseStream);
Assert.Equal(200, response.StatusCode);
Assert.Equal("OK", response.ResponseMessage);
Assert.Equal("Test Server", response.Headers.GetValue(("Server")));
Assert.Equal(2, response.ContentLength);
Assert.Equal("application/json", response.ContentType);
var buffer = new byte[2];
await response.Content.CopyToAsync(buffer);
var content = Encoding.UTF8.GetString(buffer);
Assert.Equal("{}", content);
}
public void WriteLeadingHeaders()
{
// Note that WriteLeadingHeaders should NOT write this header in WriteLeadingHeaders
var headers = new HttpHeaders {
{ "x-test", "my-value" }
};
var bytes = Encoding.UTF8.GetBytes("{}"); // length = 2
var content = new BufferContent(new ArraySegment <byte>(bytes));
var request = new HttpRequest(
verb: "PATCH",
host: "my-host.com",
path: "/some/path",
headers,
content);
var helper = new TraceAgentHttpHeaderHelper();
var tracerVersion = TracerConstants.AssemblyVersion;
var lang = FrameworkDescription.Instance.Name;
var fxVersion = FrameworkDescription.Instance.ProductVersion;
var expected = "PATCH /some/path HTTP/1.1\r\nHost: my-host.com\r\nAccept-Encoding: identity\r\nContent-Length: 2\r\nDatadog-Meta-Lang: .NET\r\nDatadog-Meta-Tracer-Version: "
+ tracerVersion + "\r\nx-datadog-tracing-enabled: false\r\nDatadog-Meta-Lang-Interpreter: "
+ lang + "\r\nDatadog-Meta-Lang-Version: "
+ fxVersion + "\r\nDatadog-Client-Computed-Top-Level: 1\r\n";
var sb = new StringBuilder();
using var textWriter = new StringWriter(sb);
helper.WriteLeadingHeaders(request, textWriter);
sb.ToString().Should().Be(expected);
}
public async Task <IApiResponse> PostAsync(ArraySegment <byte> traces)
{
using (var bidirectionalStream = _streamFactory.GetBidirectionalStream())
{
var content = new BufferContent(traces);
var request = new HttpRequest("POST", _uri.Host, _uri.PathAndQuery, _headers, content);
// send request, get response
var response = await _client.SendAsync(request, bidirectionalStream, bidirectionalStream).ConfigureAwait(false);
// Content-Length is required as we don't support chunked transfer
var contentLength = response.Content.Length;
if (!contentLength.HasValue)
{
throw new Exception("Content-Length is required but was not provided");
}
// buffer the entire contents for now
var buffer = new byte[contentLength.Value];
var responseContentStream = new MemoryStream(buffer);
await response.Content.CopyToAsync(buffer).ConfigureAwait(false);
responseContentStream.Position = 0;
return(new HttpStreamResponse(response.StatusCode, responseContentStream.Length, response.GetContentEncoding(), responseContentStream, response.Headers));
}
}
private void StartBufferContent(BufferContent result)
{
if (Parent == null)
{
// Always store buffer content at the root level
EnsureBuffers().Add(result);
}
else
{
Parent.StartBufferContent(result);
}
}
internal HxlWriter StartBufferContent(string name)
{
if (name == "spaFragments")
{
var result = new BufferContent(name);
var writer = new HxlWriter(result.Writer, new HxlWriterSettings {
TemplateContext = this
});
StartBufferContent(result);
return(writer);
}
throw new NotImplementedException();
}
public void TestSetup()
{
usefulData = Guid.NewGuid().ToByteArray();
totalBuffer = Guid.NewGuid()
.ToByteArray()
.Concat(usefulData)
.Concat(Guid.NewGuid().ToByteArray())
.ToArray();
cancellation = new CancellationTokenSource();
content = new BufferContent(new Content(totalBuffer, usefulData.Length, usefulData.Length), cancellation.Token);
}
public void Should_be_read_as_correct_portion_of_large_buffer()
{
usefulData = new byte[100 * 1000];
new Random(Guid.NewGuid().GetHashCode()).NextBytes(usefulData);
totalBuffer = Guid.NewGuid()
.ToByteArray()
.Concat(usefulData)
.Concat(Guid.NewGuid().ToByteArray())
.ToArray();
content = new BufferContent(new Content(totalBuffer, 16, usefulData.Length), cancellation.Token);
content.ReadAsByteArrayAsync().Result.Should().Equal(usefulData);
}
public void GetPoints(out Point[] Points, int id)
{
double yFactor = (GraphRect.Height - 10) / (Maximum - Minimum);
double xFactor = (GraphRect.Width * m_viewWidth) / Channels[0].Length;
float x;
float y;
int index;
Points = null;
try
{
RingBuffer <float> channel = Channels[id];
if (channel.Length == 0)
{
return;
}
Points = new Point[channel.Length];
index = 0;
BufferContent <float> iterator = channel.GetFirst();
for (index = 0; index < channel.Length; index++)
{
if (iterator == null)
{
Points[index] = (Points[index - 1]);
}
else
{
x = (float)((index * xFactor) + GraphRect.X);
y = (float)(GraphRect.Height - (((Math.Max(Convert.ToDouble(iterator.Content), Minimum) - Minimum) * yFactor)));
Points[index] = new Point(x, y);
iterator = iterator.Next;
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
