async Task <DogEmbedGraph> IEmbedApi.CreateAsync(DogEmbedCreateParameter param, CancellationToken?cancelToken)
{
var sb = new StringBuilder();
sb.Append("graph_json=").Append(WebUtility.UrlEncode(param.GraphJson));
if (!string.IsNullOrEmpty(param.Timeframe))
{
sb.Append("&timeframe=").Append(WebUtility.UrlEncode(param.Timeframe));
}
if (!string.IsNullOrEmpty(param.Size))
{
sb.Append("&size=").Append(WebUtility.UrlEncode(param.Size));
}
if (param.Legend.HasValue)
{
sb.Append("&legend=").Append(param.Legend.Value ? "yes" : "no");
}
if (!string.IsNullOrEmpty(param.Title))
{
sb.Append("&title=").Append(WebUtility.UrlEncode(param.Title));
}
var data = new DogApiHttpRequestContent("application/x-www-form-urlencoded",
Encoding.UTF8.GetBytes(sb.ToString()));
return(await RequestAsync <DogEmbedGraph>(HttpMethod.Post, $"/api/v1/graph/embed", null, data, cancelToken)
.ConfigureAwait(false));
}
async Task <DogScreenboard> IScreenboardApi.UpdateAsync(DogScreenboard screenBoard,
CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(screenBoard));
return(await RequestAsync <DogScreenboard>(HttpMethod.Put, $"/api/v1/screen/{screenBoard.Id}", null, data,
cancelToken).ConfigureAwait(false));
}
async Task <DogHostUnmuteResult> IHostApi.UnmuteAsync(string hostName, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", new byte[0]);
return(await RequestAsync <DogHostUnmuteResult>(HttpMethod.Post, $"/api/v1/host/{hostName}/unmute", null,
data, cancelToken)
.ConfigureAwait(false));
}
async Task <DogUser> IUserApi.UpdateAsync(DogUser user, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(user));
var result =
await RequestAsync <DogUserResult>(HttpMethod.Put, $"/api/v1/user/{user.Handle}", null, data,
cancelToken).ConfigureAwait(false);
return(result.User);
}
async Task <DogComment> ICommentApi.UpdateAsync(DogComment comment, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(comment));
var result = await RequestAsync <DogCommentCreateUpdateResult>(HttpMethod.Put,
$"/api/v1/comments/{comment.Id}", null, data,
cancelToken).ConfigureAwait(false);
return(result.Comment);
}
async Task <DogMetricPostResult> IMetricApi.PostAsync(DogMetric[] metrics, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(new DogMetricPostParameter()
{
Series = metrics
}, Utf8Json.Resolvers.StandardResolver.ExcludeNull));
return(await RequestAsync <DogMetricPostResult>(HttpMethod.Post, "/api/v1/series", null, data, cancelToken).ConfigureAwait(false));
}
async Task <DogServiceCheckPostResult> IServiceCheckApi.PostAsync(DogServiceCheckPostParameter param,
CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json",
JsonSerializer.Serialize(param, StandardResolver.ExcludeNull));
return(await RequestAsync <DogServiceCheckPostResult>(HttpMethod.Post, "/api/v1/check_run", null, data,
cancelToken).ConfigureAwait(false));
}
async Task <DogMetadata> IMetadataApi.UpdateAsync(DogMetadata metadata, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(metadata));
var updatedMetadata =
await RequestAsync <DogMetadata>(HttpMethod.Put, $"/api/v1/metrics/{metadata.Metric}", null, data,
cancelToken).ConfigureAwait(false);
updatedMetadata.Metric = metadata.Metric;
return(updatedMetadata);
}
async Task <DogDashboardList> IDashboardListApi.UpdateAsync(long id, string name, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json",
JsonSerializer.Serialize(new DogDashboardListCreateUpdateParameter {
Name = name
}));
return(await RequestAsync <DogDashboardList>(HttpMethod.Put, $"/api/v1/dashboard/lists/manual/{id}", null,
data, cancelToken).ConfigureAwait(false));
}
async Task <DogDashboardListItem[]> IDashboardListApi.UpdateItemsAsync(long id, DogDashboardListItem[] items,
CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json",
JsonSerializer.Serialize(new DogDashboardListAddUpdateItemsParameter {
Dashboards = items
}));
var result = await RequestAsync <DogDashboardListUpdateItemsResult>(HttpMethod.Put,
$"/api/v1/dashboard/lists/manual/{id}/dashboards", null,
data, cancelToken).ConfigureAwait(false);
return(result.Dashboards);
}
async Task <DogHostMuteResult> IHostApi.MuteAsync(string hostName, DateTimeOffset?end, string message,
bool? @override, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json",
JsonSerializer.Serialize(
new DogHostMuteParameter {
End = end, Message = message, Override = @override
},
StandardResolver.ExcludeNull));
return(await RequestAsync <DogHostMuteResult>(HttpMethod.Post, $"/api/v1/host/{hostName}/mute", null,
data, cancelToken)
.ConfigureAwait(false));
}
async Task <DogUser> IUserApi.CreateAsync(string handle, string name, string accessRole,
CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json",
JsonSerializer.Serialize(new DogUserCreateParameter
{
Handle = handle,
Name = name,
AccessRole = accessRole
}));
var result = await RequestAsync <DogUserResult>(HttpMethod.Post, "/api/v1/user", null, data, cancelToken)
.ConfigureAwait(false);
return(result.User);
}
async Task <DogTimeboard> ITimeboardApi.CreateAsync(DogTimeboard timeboard,
CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(timeboard));
var result = await RequestAsync <DogTimeboardResult>(HttpMethod.Post, "/api/v1/dash", null, data,
cancelToken).ConfigureAwait(false);
if (result.Timeboard != null)
{
result.Timeboard.Url = result.Url;
result.Timeboard.Resource = result.Resource;
}
return(result.Timeboard);
}
async Task <string[]> ITagApi.UpdateAsync(string hostName, string[] tags, string source,
CancellationToken?cancelToken)
{
var @params = new NameValueCollection();
if (source != null)
{
@params["source"] = source;
}
var data = new DogApiHttpRequestContent("application/json",
JsonSerializer.Serialize(new DogTagCreateUpdateParameter {
Tags = tags
}));
var result =
await RequestAsync <DogTagCreateUpdateResult>(HttpMethod.Put,
$"/api/v1/tags/hosts/{Uri.EscapeDataString(hostName)}", @params, data,
cancelToken)
.ConfigureAwait(false);
return(result?.Tags ?? new string[0]);
}
async Task <DogEventPostResult> IEventApi.PostAsync(DogEventPostParameter param, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(param, Utf8Json.Resolvers.StandardResolver.ExcludeNull));
return(await RequestAsync <DogEventPostResult>(HttpMethod.Post, "/api/v1/events", null, data, cancelToken));
}
public override async Task <DogApiHttpResponseContent> RequestAsync(HttpMethod method, string url, NameValueCollection headers, NameValueCollection @params, DogApiHttpRequestContent requestContent, CancellationToken cancelToken)
{
using (var request = new HttpRequestMessage(method, CreateUrlWithQueryString(url, @params)))
{
if (headers != null)
{
foreach (var headerName in headers.AllKeys)
{
request.Headers.Add(headerName, headers.GetValues(headerName));
}
}
if (requestContent != null)
{
var httpContent = new ByteArrayContent(requestContent.Data);
httpContent.Headers.ContentType = new MediaTypeHeaderValue(requestContent.ContentType);
request.Content = httpContent;
}
using (var response = await httpClient.SendAsync(request, cancelToken))
{
try
{
var content = await response.Content.ReadAsByteArrayAsync();
return(new DogApiHttpResponseContent()
{
StatusCode = response.StatusCode, Data = content, MediaType = response.Content.Headers?.ContentType?.MediaType
});
}
catch (Exception ex)
{
throw new DogApiClientHttpException(ex);
}
}
}
}
}; // CancellationTokenでタイムアウトを指定するので;
public override async Task <DogApiHttpResponseContent> RequestAsync(HttpMethod method, string url, NameValueCollection headers, NameValueCollection @params, DogApiHttpRequestContent data, TimeSpan timeOut)
{
using (var csc = new CancellationTokenSource(timeOut))
{
try
{
return(await RequestAsync(method, url, headers, @params, data, csc.Token));
}
catch (OperationCanceledException)
{
throw new DogApiClientTimeoutException();
}
}
}
public abstract Task <DogApiHttpResponseContent> RequestAsync(HttpMethod method, string url,
NameValueCollection headers, NameValueCollection @params, DogApiHttpRequestContent data, TimeSpan timeOut);
public abstract Task <DogApiHttpResponseContent> RequestAsync(HttpMethod method, string url,
NameValueCollection headers, NameValueCollection @params, DogApiHttpRequestContent data,
CancellationToken cancelToken);
public override async Task <DogApiHttpResponseContent> RequestAsync(HttpMethod method, string url,
NameValueCollection headers, NameValueCollection @params, DogApiHttpRequestContent requestContent,
CancellationToken cancelToken)
{
using (var request = new HttpRequestMessage(method, CreateUrlWithQueryString(url, @params)))
{
if (headers != null)
{
foreach (var headerName in headers.AllKeys)
{
request.Headers.Add(headerName, headers.GetValues(headerName));
}
}
if (requestContent != null)
{
var httpContent = new ByteArrayContent(requestContent.Data);
httpContent.Headers.ContentType = new MediaTypeHeaderValue(requestContent.ContentType);
request.Content = httpContent;
}
using (var response = await HttpClient.SendAsync(request, cancelToken).ConfigureAwait(false))
{
try
{
var responseHeaders = response.Headers;
var limit = GetResponseHeaderValue(responseHeaders, "X-RateLimit-Limit");
var period = GetResponseHeaderValue(responseHeaders, "X-RateLimit-Period");
var remaining = GetResponseHeaderValue(responseHeaders, "X-RateLimit-Remaining");
var reset = GetResponseHeaderValue(responseHeaders, "X-RateLimit-Reset");
DogApiRateLimit rateLimit = null;
if (limit != null && period != null && remaining != null && reset != null)
{
rateLimit = new DogApiRateLimit(limit.Value, period.Value, remaining.Value, reset.Value);
}
var content = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
return(new DogApiHttpResponseContent
{
StatusCode = response.StatusCode,
Data = content,
MediaType = response.Content.Headers?.ContentType?.MediaType,
RateLimit = rateLimit
});
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
throw new DogApiClientHttpException(ex);
}
}
}
}
private async Task <T> RequestAsync <T>(HttpMethod method, string path, NameValueCollection @params, DogApiHttpRequestContent data, CancellationToken?cancelToken)
{
@params = @params == null
? new NameValueCollection()
: new NameValueCollection(@params);
@params.Add("api_key", ApiKey);
if (AppKey != null)
{
@params.Add("application_key", AppKey);
}
var url = DataDogHost + path;
DogApiHttpResponseContent content;
try
{
content = await(cancelToken.HasValue
? httpClient.RequestAsync(method, url, null, @params, data, cancelToken.Value).ConfigureAwait(false)
: httpClient.RequestAsync(method, url, null, @params, data, Timeout).ConfigureAwait(false));
}
catch (DogApiClientException)
{
throw;
}
catch (Exception ex)
{
throw new DogApiClientException("http request error", ex);
}
if ((int)content.StatusCode >= 200 && (int)content.StatusCode < 300)
{
T result;
try
{
result = JsonSerializer.Deserialize <T>(content.Data);
}
catch (Exception ex)
{
throw new DogApiClientInvalidJsonException(content.Data, ex);
}
return(result);
}
else
{
if (content.MediaType == "application/json" || content.MediaType == "text/json")
{
DogApiErrorInfo errorInfo;
try
{
errorInfo = JsonSerializer.Deserialize <DogApiErrorInfo>(content.Data);
}
catch (Exception ex)
{
throw new DogApiClientInvalidJsonException(content.Data, ex);
}
throw new DogApiErrorException(content.StatusCode, errorInfo.Errors);
}
else
{
throw new DogApiClientHttpException(content.StatusCode);
}
}
}
async Task <DogMetadataUpdateResult> IMetadataApi.UpdateAsync(DogMetadataUpdateParameter param, CancellationToken?cancelToken)
{
var data = new DogApiHttpRequestContent("application/json", JsonSerializer.Serialize(param));
return(await RequestAsync <DogMetadataUpdateResult>(HttpMethod.Put, $"/api/v1/metrics/{param.Metric}", null, data, cancelToken).ConfigureAwait(false));
}
