// 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(); } }