public async Task RegexTest()
{
var logGroupName = "RegexTest";
var logStreamName = "TestMessage";
Regex invalid_sequence_token_regex = new
Regex(@"The given sequenceToken is invalid. The next expected sequenceToken is: (\d+)");
client = new AmazonCloudWatchLogsClient(RegionEndpoint.USWest2);
await client.CreateLogGroupAsync(new CreateLogGroupRequest
{
LogGroupName = logGroupName
});
_testFixure.LogGroupNameList.Add(logGroupName);
await client.CreateLogStreamAsync(new CreateLogStreamRequest
{
LogGroupName = logGroupName,
LogStreamName = logStreamName
});
var putlogEventsRequest = new PutLogEventsRequest
{
LogGroupName = logGroupName,
LogStreamName = logStreamName,
LogEvents = new List <InputLogEvent>
{
new InputLogEvent
{
Timestamp = DateTime.Now,
Message = "Message1"
}
}
};
var response = await client.PutLogEventsAsync(putlogEventsRequest);
try
{
putlogEventsRequest.LogEvents = new List <InputLogEvent>
{
new InputLogEvent
{
Timestamp = DateTime.Now,
Message = "Message2"
}
};
await client.PutLogEventsAsync(putlogEventsRequest);
}
catch (InvalidSequenceTokenException ex)
{
var regexResult = invalid_sequence_token_regex.Match(ex.Message);
if (regexResult.Success)
{
Assert.Equal(regexResult.Groups[1].Value, response.NextSequenceToken);
}
}
}
private async void PutLog(string groupName, string streamName, string msg)
{
try
{
var req = new DescribeLogStreamsRequest(groupName)
{
LogStreamNamePrefix = streamName
};
var resp = await _logsClient.DescribeLogStreamsAsync(req);
var token = resp.LogStreams.FirstOrDefault(s => s.LogStreamName == streamName)?.UploadSequenceToken;
var ie = new InputLogEvent
{
Message = msg,
Timestamp = DateTime.UtcNow
};
var request = new PutLogEventsRequest(groupName, streamName, new List <InputLogEvent> {
ie
});
if (!string.IsNullOrEmpty(token))
{
request.SequenceToken = token;
}
await _logsClient.PutLogEventsAsync(request);
}
catch (Exception e)
{
// ignored
}
}
/// <summary>
/// Saves log messages from the cache.
/// </summary>
/// <param name="messages">a list with log messages</param>
protected override void Save(List <LogMessage> messages)
{
if (messages == null || messages.Count == 0)
{
return;
}
if (_client == null)
{
throw new InvalidStateException(
"cloudwatch_logger", "NOT_OPENED", "CloudWatchLogger is not opened"
);
}
lock (_lock)
{
var events = new List <InputLogEvent>();
foreach (var message in messages)
{
events.Add(new InputLogEvent
{
Timestamp = message.Time,
Message = FormatMessageText(message)
});
}
try
{
var result = _client.PutLogEventsAsync(new PutLogEventsRequest
{
LogGroupName = _group,
LogStreamName = _stream,
SequenceToken = _lastToken,
LogEvents = events
}
).Result;
_lastToken = result.NextSequenceToken;
}
catch
{
// Do nothing if elastic search client was not enable to process bulk of messages
}
}
}
private async Task Worker(CancellationToken cancellationToken)
{
string sequenceToken = await GetSequenceToken(LogGroupName, LogStreamName);
while (!cancellationToken.IsCancellationRequested)
{
try
{
cancellationToken.ThrowIfCancellationRequested();
LogEvent logEvent = await _queue.DequeueAsync(cancellationToken);
var request = new PutLogEventsRequest(LogGroupName, LogStreamName, new List <InputLogEvent>
{
new InputLogEvent
{
Message = logEvent.RenderMessage(),
Timestamp = logEvent.Timestamp.UtcDateTime,
}
});
request.SequenceToken = sequenceToken;
var resp = await _client.PutLogEventsAsync(request, cancellationToken);
sequenceToken = resp.NextSequenceToken;
}
catch (OperationCanceledException e)
{
Console.Error.WriteLine($"Worker canceled: {e}.");
throw;
}
catch (Exception e)
{
Console.Error.WriteLine($"Worker exception occured: {e}.");
}
}
Console.Error.WriteLine("Worker ended.");
}
/// <summary>
///
/// <para>WriteLogs:</para>
///
/// <para>Writes logs to the logging service</para>
///
/// <para>Check <seealso cref="IBLoggingServiceInterface.WriteLogs"/> for detailed documentation</para>
///
/// </summary>
public bool WriteLogs(
List <BLoggingParametersStruct> _Messages,
string _LogGroupName,
string _LogStreamName,
bool _bAsync = true,
Action <string> _ErrorMessageAction = null)
{
if (_Messages == null || _Messages.Count == 0)
{
return(false);
}
if (_bAsync)
{
BTaskWrapper.Run(() =>
{
WriteLogs(_Messages, _LogGroupName, _LogStreamName, false, _ErrorMessageAction);
});
return(true);
}
else
{
_LogGroupName = BUtility.EncodeStringForTagging(_LogGroupName);
_LogStreamName = BUtility.EncodeStringForTagging(_LogStreamName);
string SequenceToken = null;
bool bLogStreamAndGroupExists = false;
try
{
var DescribeStreamRequest = new DescribeLogStreamsRequest(_LogGroupName);
using (var CreatedDescribeTask = CloudWatchLogsClient.DescribeLogStreamsAsync(DescribeStreamRequest))
{
CreatedDescribeTask.Wait();
if (CreatedDescribeTask.Result != null && CreatedDescribeTask.Result.LogStreams != null && CreatedDescribeTask.Result.LogStreams.Count > 0)
{
foreach (var Current in CreatedDescribeTask.Result.LogStreams)
{
if (Current != null && Current.LogStreamName == _LogStreamName)
{
SequenceToken = Current.UploadSequenceToken;
bLogStreamAndGroupExists = true;
break;
}
}
}
}
}
catch (Exception)
{
bLogStreamAndGroupExists = false;
}
if (!bLogStreamAndGroupExists)
{
try
{
var CreateGroupRequest = new CreateLogGroupRequest(_LogGroupName);
using (var CreatedGroupTask = CloudWatchLogsClient.CreateLogGroupAsync(CreateGroupRequest))
{
CreatedGroupTask.Wait();
}
}
catch (Exception e)
{
if (!(e is ResourceAlreadyExistsException))
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
try
{
var CreateStreamRequest = new CreateLogStreamRequest(_LogGroupName, _LogStreamName);
using (var CreatedStreamTask = CloudWatchLogsClient.CreateLogStreamAsync(CreateStreamRequest))
{
CreatedStreamTask.Wait();
}
}
catch (Exception e)
{
if (!(e is ResourceAlreadyExistsException))
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
}
var LogEvents = new List <InputLogEvent>();
foreach (var Message in _Messages)
{
var LogEvent = new InputLogEvent()
{
Message = Message.Message,
Timestamp = DateTime.UtcNow
};
switch (Message.LogType)
{
case EBLoggingServiceLogType.Debug:
LogEvent.Message = "Debug-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Info:
LogEvent.Message = "Info-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Warning:
LogEvent.Message = "Warning-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Error:
LogEvent.Message = "Error-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Critical:
LogEvent.Message = "Critical-> " + LogEvent.Message;
break;
}
LogEvents.Add(LogEvent);
}
try
{
var PutRequest = new PutLogEventsRequest(_LogGroupName, _LogStreamName, LogEvents)
{
SequenceToken = SequenceToken
};
using (var CreatedPutTask = CloudWatchLogsClient.PutLogEventsAsync(PutRequest))
{
CreatedPutTask.Wait();
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
return(true);
}
}
