// snippet-start:[CloudWatchLogs.dotnetv3.CreateLogGroupExample]
public static async Task Main()
{
// This client object will be associated with the same AWS Region
// as the default user on this system. If you need to use a
// different AWS Region, pass it as a parameter to the client
// constructor.
var client = new AmazonCloudWatchLogsClient();
string logGroupName = "cloudwatchlogs-example-loggroup";
var request = new CreateLogGroupRequest
{
LogGroupName = logGroupName,
};
var response = await client.CreateLogGroupAsync(request);
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
Console.WriteLine($"Successfully create log group with ID: {logGroupName}.");
}
else
{
Console.WriteLine("Could not create log group.");
}
}
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);
}
}
}
public Task CreateLogGroupAsync(string name, CancellationToken cancellationToken = default(CancellationToken))
=> _clientLogs.CreateLogGroupAsync(new CreateLogGroupRequest()
{
LogGroupName = name,
Tags = new Dictionary <string, string>()
{
{ "Timestamp", DateTime.UtcNow.ToRfc3339String() }
}
}, cancellationToken).EnsureSuccessAsync();
public async Task TestCoreWithDisableLogGroupCreation()
{
var logGroupName = nameof(TestCoreWithDisableLogGroupCreation);
using (var client = new AmazonCloudWatchLogsClient(RegionEndpoint.USWest2))
{
var config = new AWSLoggerConfig(logGroupName)
{
Region = RegionEndpoint.USWest2.SystemName,
DisableLogGroupCreation = true,
};
var resourceNotFoundPromise = new TaskCompletionSource <bool>(); // true means we saw expected exception; false otherwise
var core = new AWSLoggerCore(config, "unit");
core.LogLibraryAlert += (sender, e) =>
{
if (e.Exception is ResourceNotFoundException)
{
// saw EXPECTED exception.
resourceNotFoundPromise.TrySetResult(true);
}
else if (e.Exception != null)
{
_output.WriteLine("Was not expecting to see exception: {0} @{1}", e.Exception, e.ServiceUrl);
}
};
var tsk = Task.Factory.StartNew(() =>
{
core.AddMessage("Test message added at " + DateTimeOffset.UtcNow.ToString());
core.Flush();
});
await Task.WhenAny(tsk, resourceNotFoundPromise.Task).ConfigureAwait(false);
resourceNotFoundPromise.TrySetResult(false);
Assert.True(await resourceNotFoundPromise.Task);
// now we create the log group, late.
await client.CreateLogGroupAsync(new CreateLogGroupRequest
{
LogGroupName = logGroupName
});
_testFixure.LogGroupNameList.Add(logGroupName);
// wait for the flusher task to finish, which should actually proceed OK, now that we've created the expected log group.
await tsk.ConfigureAwait(false);
core.Close();
}
}
private async void UploadLog(string logString, string stackTrace, LogType type)
{
// Avoid NRE
if (Agent.PrivateKey == default)
{
_msg += logString + "\n";
if (!string.IsNullOrEmpty(stackTrace))
{
_msg += stackTrace + "\n";
}
}
else
{
const string groupName = "9c-player-logs";
var streamName = _options.AwsSinkGuid;
try
{
var req = new CreateLogGroupRequest(groupName);
await _logsClient.CreateLogGroupAsync(req);
}
catch (ResourceAlreadyExistsException)
{
}
catch (ObjectDisposedException)
{
return;
}
try
{
var req = new CreateLogStreamRequest(groupName, streamName);
await _logsClient.CreateLogStreamAsync(req);
}
catch (ResourceAlreadyExistsException)
{
// ignored
}
PutLog(groupName, streamName, GetMessage(logString, stackTrace));
}
}
/// <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);
}
}
/// <summary>
/// Opens the component.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
public async Task OpenAsync(string correlationId)
{
if (IsOpen())
{
return;
}
var awsConnection = await _connectionResolver.ResolveAsync(correlationId);
// Assign service name
awsConnection.Service = "logs";
awsConnection.ResourceType = "log-group";
if (!string.IsNullOrEmpty(awsConnection.Resource))
{
_group = awsConnection.Resource;
}
// Undefined stream creates a random stream on every connect
if (string.IsNullOrEmpty(_stream))
{
_stream = IdGenerator.NextLong();
}
// Validate connection params
var err = awsConnection.Validate(correlationId);
if (err != null)
{
throw err;
}
// Create client
var region = RegionEndpoint.GetBySystemName(awsConnection.Region);
var config = new AmazonCloudWatchLogsConfig()
{
RegionEndpoint = region
};
_client = new AmazonCloudWatchLogsClient(awsConnection.AccessId, awsConnection.AccessKey, config);
// Create a log group if needed
try
{
await _client.CreateLogGroupAsync(
new CreateLogGroupRequest
{
LogGroupName = _group
}
);
}
catch (ResourceAlreadyExistsException)
{
// Ignore. Everything is ok
}
// Create or read log stream
try
{
await _client.CreateLogStreamAsync(
new CreateLogStreamRequest
{
LogGroupName = _group,
LogStreamName = _stream
}
);
_lastToken = null;
}
catch (ResourceAlreadyExistsException)
{
var response = await _client.DescribeLogStreamsAsync(
new DescribeLogStreamsRequest
{
LogGroupName = _group,
LogStreamNamePrefix = _stream
}
);
if (response.LogStreams.Count > 0)
{
_lastToken = response.LogStreams[0].UploadSequenceToken;
}
}
if (_timer == null)
{
_timer = new FixedRateTimer(OnTimer, _interval, _interval);
_timer.Start();
}
}
