public void Create_FromException_IsOk()
{
var ex = new Exception("message");
var descr = ErrorDescriptionFactory.Create(ex);
Assert.NotNull(descr);
Assert.Equal(ErrorCategory.Unknown, descr.Category);
Assert.Equal("UNKNOWN", descr.Code);
Assert.Equal(ex.Message, descr.Message);
Assert.Equal(500, descr.Status);
Assert.Equal(ex.StackTrace, descr.StackTrace);
Assert.Null(descr.CorrelationId);
ex = new Exception("message");
const string correlation = "correlation1234";
var withCorrelation = ErrorDescriptionFactory.Create(ex, correlation);
Assert.NotNull(descr);
Assert.Equal(ErrorCategory.Unknown, withCorrelation.Category);
Assert.Equal("UNKNOWN", withCorrelation.Code);
Assert.Equal(ex.Message, withCorrelation.Message);
Assert.Equal(500, withCorrelation.Status);
Assert.Equal(ex.StackTrace, withCorrelation.StackTrace);
Assert.Equal(correlation, withCorrelation.CorrelationId);
}
/// <summary>
/// Sends error serialized as ErrorDescription object and appropriate HTTP status
/// code.If status code is not defined, it uses 500 status code.
/// </summary>
/// <param name="response">a Http response</param>
/// <param name="ex">an error object to be sent.</param>
public static async Task SendErrorAsync(HttpResponse response, Exception ex)
{
// Unwrap exception
if (ex is AggregateException)
{
var ex2 = ex as AggregateException;
ex = ex2.InnerExceptions.Count > 0 ? ex2.InnerExceptions[0] : ex;
}
if (ex is PipServices3.Commons.Errors.ApplicationException)
{
response.ContentType = "application/json";
var ex3 = ex as PipServices3.Commons.Errors.ApplicationException;
response.StatusCode = ex3.Status;
var contentResult = JsonConverter.ToJson(ErrorDescriptionFactory.Create(ex3));
await response.WriteAsync(contentResult);
}
else
{
response.ContentType = "application/json";
response.StatusCode = (int)HttpStatusCode.InternalServerError;
var contentResult = JsonConverter.ToJson(ErrorDescriptionFactory.Create(ex));
await response.WriteAsync(contentResult);
}
}
public void Create_FromApplicationException_IsOk()
{
var key = "key";
var details = "details";
var ex = new ApplicationException("category", "correlationId", "code", "message")
{
Status = 777,
Cause = "cause",
StackTrace = "stackTrace"
};
ex.WithDetails(key, details);
var descr = ErrorDescriptionFactory.Create(ex);
Assert.NotNull(descr);
Assert.Equal(ex.Category, descr.Category);
Assert.Equal(ex.CorrelationId, descr.CorrelationId);
Assert.Equal(ex.Code, descr.Code);
Assert.Equal(ex.Message, descr.Message);
Assert.Equal(ex.Status, descr.Status);
Assert.Equal(ex.Cause, descr.Cause);
Assert.Equal(ex.StackTrace, descr.StackTrace);
Assert.Equal(ex.Details, descr.Details);
}
private InvokeReply CreateErrorResponse(Exception ex)
{
return(new InvokeReply
{
Error = ObjectMapper.MapTo <ErrorDescription>(ErrorDescriptionFactory.Create(ex)),
ResultEmpty = true,
ResultJson = null
});
}
public void Create_FromException_IsOk()
{
var ex = new Exception("message");
var descr = ErrorDescriptionFactory.Create(ex);
Assert.NotNull(descr);
Assert.Equal(ErrorCategory.Unknown, descr.Category);
Assert.Equal("UNKNOWN", descr.Code);
Assert.Equal(ex.Message, descr.Message);
Assert.Equal(500, descr.Status);
Assert.Equal(ex.StackTrace, descr.StackTrace);
}
static void Main(string[] args)
{
try
{
var correlationId = "123";
var config = ConfigParams.FromTuples(
"connection.type", "http",
"connection.host", "localhost",
"connection.port", 8080
);
var client = new LoggingHttpClientV1();
client.Configure(config);
LogMessageV1 message1 = new LogMessageV1()
{
Time = new DateTime(),
Source = null,
Level = LogLevel.Debug,
CorrelationId = "123",
Error = null,
Message = "BBB"
};
LogMessageV1 message2 = new LogMessageV1()
{
Time = new DateTime(),
Source = null,
Level = LogLevel.Error,
CorrelationId = "123",
Error = ErrorDescriptionFactory.Create(new Exception()),
Message = "AAB"
};
client.OpenAsync(correlationId);
client.WriteMessagesAsync(null, new LogMessageV1[] { message1, message2 });
var page = client.ReadMessagesAsync(null, FilterParams.FromTuples("search", "AA"), null);
Console.WriteLine("Read log messages: ");
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
client.CloseAsync(string.Empty);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public async Task TestCrudOperationsAsync()
{
var message = await this._client.WriteMessageAsync(null, new LogMessageV1()
{
Time = new DateTime(),
Source = null,
Level = LogLevel.Info,
CorrelationId = "123",
Error = null,
Message = "AAA"
});
Assert.NotNull(message);
var message1 = new LogMessageV1()
{
Time = new DateTime(),
Source = null,
Level = LogLevel.Debug,
CorrelationId = "123",
Error = null,
Message = "BBB"
};
var message2 = new LogMessageV1()
{
Time = new DateTime(),
Source = null,
Level = LogLevel.Error,
CorrelationId = "123",
Error = ErrorDescriptionFactory.Create(new Exception()),
Message = "AAB"
};
message2.Time = new DateTime(1975, 1, 1, 0, 0, 0, 0);
await this._client.WriteMessagesAsync(null, new LogMessageV1[] { message1, message2 });
var page = await this._client.ReadMessagesAsync(null, FilterParams.FromTuples("search", "AA"), null);
Assert.Equal(2, page.Data.Count);
page = await this._client.ReadErrorsAsync(null, null, null);
Assert.Single(page.Data);
}
/// <summary>
/// Writes a log message to the logger destination.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
/// <param name="component">a name of called component</param>
/// <param name="operation">a name of the executed operation. </param>
/// <param name="error">an error object associated with this trace.</param>
/// <param name="duration">execution duration in milliseconds. </param>
protected void Write(string correlationId, string component, string operation, Exception error, long duration)
{
ErrorDescription errorDesc = error != null?ErrorDescriptionFactory.Create(error) : null;
OperationTrace trace = new OperationTrace
{
Time = DateTime.UtcNow,
Source = _source,
Component = component,
Operation = operation,
CorrelationId = correlationId,
Duration = duration,
Error = errorDesc
};
_cache.Add(trace);
Update();
}
/// <summary>
/// Writes a log message to the logger destination.
/// </summary>
/// <param name="level">a log level.</param>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
/// <param name="error">an error object associated with this message.</param>
/// <param name="message">a human-readable message to log.</param>
protected override void Write(LogLevel level, string correlationId, Exception error, string message)
{
ErrorDescription errorDescription = error != null?ErrorDescriptionFactory.Create(error, correlationId) : null;
LogMessage logMessage = new LogMessage()
{
Time = DateTime.UtcNow,
Level = LogLevelConverter.ToString(level),
Source = _source,
Error = errorDescription,
Message = message,
CorrelationId = correlationId
};
lock (_lock)
{
_cache.Add(logMessage);
}
Update();
}
private async Task <HttpResponseMessage> ExecuteRequestAsync(
string correlationId, HttpMethod method, Uri uri, HttpContent content = null)
{
if (_client == null)
{
throw new InvalidOperationException("REST client is not configured");
}
// Set headers
foreach (var key in _headers.Keys)
{
if (!_client.DefaultRequestHeaders.Contains(key))
{
_client.DefaultRequestHeaders.Add(key, _headers[key]);
}
}
HttpResponseMessage result = null;
var retries = Math.Min(1, Math.Max(5, _retries));
while (retries > 0)
{
try
{
if (method == HttpMethod.Get)
{
result = await _client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead);
}
else if (method == HttpMethod.Post)
{
result = await _client.PostAsync(uri, content);
}
else if (method == HttpMethod.Put)
{
result = await _client.PutAsync(uri, content);
}
else if (method == HttpMethod.Delete)
{
result = await _client.DeleteAsync(uri);
}
#if !NETSTANDARD2_0
else if (method == HttpMethod.Patch)
{
result = await _client.PatchAsync(uri, content);
}
#endif
else
{
throw new InvalidOperationException("Invalid request type");
}
retries = 0;
}
catch (HttpRequestException ex)
{
retries--;
if (retries > 0)
{
throw new ConnectionException(correlationId, null, "Unknown communication problem on REST client", ex);
}
else
{
_logger.Trace(correlationId, $"Connection failed to uri '{uri}'. Retrying...");
}
}
}
if (result == null)
{
throw ApplicationExceptionFactory.Create(ErrorDescriptionFactory.Create(
new UnknownException(correlationId, $"Unable to get a result from uri '{uri}' with method '{method}'")));
}
if ((int)result.StatusCode >= 400)
{
var responseContent = await result.Content.ReadAsStringAsync();
ErrorDescription errorObject = null;
try
{
errorObject = JsonConverter.FromJson <ErrorDescription>(responseContent);
}
finally
{
if (errorObject == null)
{
errorObject = ErrorDescriptionFactory.Create(new UnknownException(correlationId, $"UNKNOWN_ERROR with result status: '{result.StatusCode}'", responseContent));
}
}
throw ApplicationExceptionFactory.Create(errorObject);
}
return(result);
}
