public async stt::Task WriteLogEntriesResourceNamesAsync()
        {
            moq::Mock <LoggingServiceV2.LoggingServiceV2Client> mockGrpcClient = new moq::Mock <LoggingServiceV2.LoggingServiceV2Client>(moq::MockBehavior.Strict);
            WriteLogEntriesRequest request = new WriteLogEntriesRequest
            {
                LogNameAsLogName = LogName.FromProjectLog("[PROJECT]", "[LOG]"),
                Resource         = new ga::MonitoredResource(),
                Labels           =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                Entries = { new LogEntry(), },
            };
            WriteLogEntriesResponse expectedResponse = new WriteLogEntriesResponse {
            };

            mockGrpcClient.Setup(x => x.WriteLogEntriesAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <WriteLogEntriesResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            LoggingServiceV2Client  client = new LoggingServiceV2ClientImpl(mockGrpcClient.Object, null);
            WriteLogEntriesResponse responseCallSettings = await client.WriteLogEntriesAsync(request.LogNameAsLogName, request.Resource, request.Labels, request.Entries, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            WriteLogEntriesResponse responseCancellationToken = await client.WriteLogEntriesAsync(request.LogNameAsLogName, request.Resource, request.Labels, request.Entries, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Exemple #2
0
        public static int Main(string[] args)
        {
            // Read projectId from args
            if (args.Length != 1)
            {
                Console.WriteLine("Usage: Project ID must be passed as first argument.");
                Console.WriteLine();
                return(1);
            }
            string projectId = args[0];

            // Create client
            LoggingServiceV2Client client = LoggingServiceV2Client.Create();

            // Initialize request argument(s)
            LogNameOneof                 logName  = LogNameOneof.From(new LogName(projectId, $"test-{Guid.NewGuid()}"));
            MonitoredResource            resource = new MonitoredResource();
            IDictionary <string, string> labels   = new Dictionary <string, string>();
            IEnumerable <LogEntry>       entries  = new List <LogEntry>();

            // Call API method
            WriteLogEntriesResponse response = client.WriteLogEntries(logName, resource, labels, entries);

            // Show the result
            Console.WriteLine(response);

            // Success
            Console.WriteLine("Smoke test passed OK");
            return(0);
        }
        public void WriteLogEntriesResourceNames()
        {
            moq::Mock <LoggingServiceV2.LoggingServiceV2Client> mockGrpcClient = new moq::Mock <LoggingServiceV2.LoggingServiceV2Client>(moq::MockBehavior.Strict);
            WriteLogEntriesRequest request = new WriteLogEntriesRequest
            {
                LogNameAsLogName = LogName.FromProjectLog("[PROJECT]", "[LOG]"),
                Resource         = new ga::MonitoredResource(),
                Labels           =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                Entries = { new LogEntry(), },
            };
            WriteLogEntriesResponse expectedResponse = new WriteLogEntriesResponse {
            };

            mockGrpcClient.Setup(x => x.WriteLogEntries(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            LoggingServiceV2Client  client   = new LoggingServiceV2ClientImpl(mockGrpcClient.Object, null);
            WriteLogEntriesResponse response = client.WriteLogEntries(request.LogNameAsLogName, request.Resource, request.Labels, request.Entries);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
 /// <summary>Snippet for WriteLogEntries</summary>
 public void WriteLogEntries_RequestObject()
 {
     // Snippet: WriteLogEntries(WriteLogEntriesRequest,CallSettings)
     // Create client
     LoggingServiceV2Client loggingServiceV2Client = LoggingServiceV2Client.Create();
     // Initialize request argument(s)
     WriteLogEntriesRequest request = new WriteLogEntriesRequest
     {
         Entries = { },
     };
     // Make the request
     WriteLogEntriesResponse response = loggingServiceV2Client.WriteLogEntries(request);
     // End snippet
 }
 /// <summary>Snippet for WriteLogEntries</summary>
 public void WriteLogEntries()
 {
     // Snippet: WriteLogEntries(LogNameOneof,MonitoredResource,IDictionary<string, string>,IEnumerable<LogEntry>,CallSettings)
     // Create client
     LoggingServiceV2Client loggingServiceV2Client = LoggingServiceV2Client.Create();
     // Initialize request argument(s)
     LogNameOneof                 logName  = LogNameOneof.From(new LogName("[PROJECT]", "[LOG]"));
     MonitoredResource            resource = new MonitoredResource();
     IDictionary <string, string> labels   = new Dictionary <string, string>();
     IEnumerable <LogEntry>       entries  = new List <LogEntry>();
     // Make the request
     WriteLogEntriesResponse response = loggingServiceV2Client.WriteLogEntries(logName, resource, labels, entries);
     // End snippet
 }
        /// <summary>Snippet for WriteLogEntriesAsync</summary>
        public async Task WriteLogEntriesAsync_RequestObject()
        {
            // Snippet: WriteLogEntriesAsync(WriteLogEntriesRequest,CallSettings)
            // Create client
            LoggingServiceV2Client loggingServiceV2Client = await LoggingServiceV2Client.CreateAsync();

            // Initialize request argument(s)
            WriteLogEntriesRequest request = new WriteLogEntriesRequest
            {
                Entries = { },
            };
            // Make the request
            WriteLogEntriesResponse response = await loggingServiceV2Client.WriteLogEntriesAsync(request);

            // End snippet
        }
        public async Task WriteLogEntriesAsync()
        {
            // Snippet: WriteLogEntriesAsync(string,MonitoredResource,IDictionary<string, string>,IEnumerable<LogEntry>,CallSettings)
            // Additional: WriteLogEntriesAsync(string,MonitoredResource,IDictionary<string, string>,IEnumerable<LogEntry>,CancellationToken)
            // Create client
            LoggingServiceV2Client loggingServiceV2Client = LoggingServiceV2Client.Create();
            // Initialize request argument(s)
            string                       formattedLogName = LoggingServiceV2Client.FormatLogName("[PROJECT]", "[LOG]");
            MonitoredResource            resource         = new MonitoredResource();
            IDictionary <string, string> labels           = new Dictionary <string, string>();
            IEnumerable <LogEntry>       entries          = new List <LogEntry>();
            // Make the request
            WriteLogEntriesResponse response = await loggingServiceV2Client.WriteLogEntriesAsync(formattedLogName, resource, labels, entries);

            // End snippet
        }
Exemple #8
0
        public async Task WriteLogEntriesAsync2()
        {
            Mock <LoggingServiceV2.LoggingServiceV2Client> mockGrpcClient = new Mock <LoggingServiceV2.LoggingServiceV2Client>(MockBehavior.Strict);
            WriteLogEntriesRequest request = new WriteLogEntriesRequest
            {
                Entries = { },
            };
            WriteLogEntriesResponse expectedResponse = new WriteLogEntriesResponse();

            mockGrpcClient.Setup(x => x.WriteLogEntriesAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <WriteLogEntriesResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            LoggingServiceV2Client  client   = new LoggingServiceV2ClientImpl(mockGrpcClient.Object, null);
            WriteLogEntriesResponse response = await client.WriteLogEntriesAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Exemple #9
0
        public void WriteLogEntries2()
        {
            Mock <LoggingServiceV2.LoggingServiceV2Client> mockGrpcClient = new Mock <LoggingServiceV2.LoggingServiceV2Client>(MockBehavior.Strict);
            WriteLogEntriesRequest request = new WriteLogEntriesRequest
            {
                Entries = { },
            };
            WriteLogEntriesResponse expectedResponse = new WriteLogEntriesResponse();

            mockGrpcClient.Setup(x => x.WriteLogEntries(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            LoggingServiceV2Client  client   = new LoggingServiceV2ClientImpl(mockGrpcClient.Object, null);
            WriteLogEntriesResponse response = client.WriteLogEntries(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Exemple #10
0
        public async Task WriteLogEntriesAsync()
        {
            Mock <LoggingServiceV2.LoggingServiceV2Client> mockGrpcClient = new Mock <LoggingServiceV2.LoggingServiceV2Client>(MockBehavior.Strict);
            WriteLogEntriesRequest expectedRequest = new WriteLogEntriesRequest
            {
                LogNameAsLogNameOneof = LogNameOneof.From(new LogName("[PROJECT]", "[LOG]")),
                Resource = new MonitoredResource(),
                Labels   = { },
                Entries  = { },
            };
            WriteLogEntriesResponse expectedResponse = new WriteLogEntriesResponse();

            mockGrpcClient.Setup(x => x.WriteLogEntriesAsync(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <WriteLogEntriesResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            LoggingServiceV2Client       client   = new LoggingServiceV2ClientImpl(mockGrpcClient.Object, null);
            LogNameOneof                 logName  = LogNameOneof.From(new LogName("[PROJECT]", "[LOG]"));
            MonitoredResource            resource = new MonitoredResource();
            IDictionary <string, string> labels   = new Dictionary <string, string>();
            IEnumerable <LogEntry>       entries  = new List <LogEntry>();
            WriteLogEntriesResponse      response = await client.WriteLogEntriesAsync(logName, resource, labels, entries);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Exemple #11
0
        protected override void ProcessRecord()
        {
            LogName = PrefixProjectToLogName(LogName, Project);
            if (MonitoredResource == null)
            {
                MonitoredResource = new MonitoredResource()
                {
                    Type   = "global",
                    Labels = new Dictionary <string, string>()
                    {
                        { "project_id", Project }
                    }
                };
            }
            List <LogEntry> entries = new List <LogEntry>();

            switch (ParameterSetName)
            {
            case ParameterSetNames.TextPayload:
                foreach (string text in TextPayload)
                {
                    LogEntry entry = new LogEntry()
                    {
                        LogName     = LogName,
                        Severity    = Enum.GetName(typeof(LogSeverity), Severity),
                        Resource    = MonitoredResource,
                        TextPayload = text
                    };
                    entries.Add(entry);
                }
                break;

            case ParameterSetNames.ProtoPayload:
                foreach (Hashtable hashTable in ProtoPayload)
                {
                    LogEntry entry = new LogEntry()
                    {
                        LogName      = LogName,
                        Severity     = Enum.GetName(typeof(LogSeverity), Severity),
                        Resource     = MonitoredResource,
                        ProtoPayload = ConvertToDictionary <string, object>(hashTable)
                    };
                    entries.Add(entry);
                }
                break;

            case ParameterSetNames.JsonPayload:
                foreach (Hashtable hashTable in JsonPayload)
                {
                    LogEntry entry = new LogEntry()
                    {
                        LogName     = LogName,
                        Severity    = Enum.GetName(typeof(LogSeverity), Severity),
                        Resource    = MonitoredResource,
                        JsonPayload = ConvertToDictionary <string, object>(hashTable)
                    };
                    entries.Add(entry);
                }
                break;

            default:
                throw UnknownParameterSetException;
            }

            WriteLogEntriesRequest writeRequest = new WriteLogEntriesRequest()
            {
                Entries  = entries,
                LogName  = LogName,
                Resource = MonitoredResource
            };

            EntriesResource.WriteRequest request  = Service.Entries.Write(writeRequest);
            WriteLogEntriesResponse      response = request.Execute();
        }