Logging quickstart

  using 
  
 System 
 ; 
 // Imports the Google Cloud Logging client library 
 using 
  
  Google.Cloud.Logging.V2 
 
 ; 
 using 
  
  Google.Cloud.Logging.Type 
 
 ; 
 using 
  
 System.Collections.Generic 
 ; 
 using 
  
  Google.Api 
 
 ; 
 namespace 
  
 GoogleCloudSamples 
 { 
  
 public 
  
 class 
  
 QuickStart 
  
 { 
  
 public 
  
 static 
  
 void 
  
 Main 
 ( 
 string 
 [] 
  
 args 
 ) 
  
 { 
  
 // Your Google Cloud Platform project ID. 
  
 string 
  
 projectId 
  
 = 
  
 "YOUR-PROJECT-ID" 
 ; 
  
 // Instantiates a client. 
  
 var 
  
 client 
  
 = 
  
  LoggingServiceV2Client 
 
 . 
  Create 
 
 (); 
  
 // Prepare new log entry. 
  
  LogEntry 
 
  
 logEntry 
  
 = 
  
 new 
  
  LogEntry 
 
 (); 
  
 string 
  
 logId 
  
 = 
  
 "my-log" 
 ; 
  
  LogName 
 
  
 logName 
  
 = 
  
 new 
  
  LogName 
 
 ( 
 projectId 
 , 
  
 logId 
 ); 
  
 logEntry 
 . 
  LogNameAsLogName 
 
  
 = 
  
 logName 
 ; 
  
 logEntry 
 . 
  Severity 
 
  
 = 
  
  LogSeverity 
 
 . 
  Info 
 
 ; 
  
 // Create log entry message. 
  
 string 
  
 message 
  
 = 
  
 "Hello World!" 
 ; 
  
 string 
  
 messageId 
  
 = 
  
 DateTime 
 . 
 Now 
 . 
 Millisecond 
 . 
 ToString 
 (); 
  
 Type 
  
 myType 
  
 = 
  
 typeof 
 ( 
 QuickStart 
 ); 
  
 string 
  
 entrySeverity 
  
 = 
  
 logEntry 
 . 
  Severity 
 
 . 
 ToString 
 (). 
 ToUpper 
 (); 
  
 logEntry 
 . 
  TextPayload 
 
  
 = 
  
 $"{messageId} {entrySeverity} {myType.Namespace}.LoggingSample - {message}" 
 ; 
  
 // Set the resource type to control which GCP resource the log entry belongs to. 
  
 // See the list of resource types at: 
  
 // https://cloud.google.com/logging/docs/api/v2/resource-list 
  
 // This sample uses resource type 'global' causing log entries to appear in the 
  
 // "Global" resource list of the Developers Console Logs Viewer: 
  
 //  https://console.cloud.google.com/logs/viewer 
  
  MonitoredResource 
 
  
 resource 
  
 = 
  
 new 
  
  MonitoredResource 
 
  
 { 
  
 Type 
  
 = 
  
 "global" 
  
 }; 
  
 // Create dictionary object to add custom labels to the log entry. 
  
 IDictionary<string 
 , 
  
 string 
>  
 entryLabels 
  
 = 
  
 new 
  
 Dictionary<string 
 , 
  
 string 
> (); 
  
 entryLabels 
 . 
  Add 
 
 ( 
 "size" 
 , 
  
 "large" 
 ); 
  
 entryLabels 
 . 
  Add 
 
 ( 
 "color" 
 , 
  
 "red" 
 ); 
  
 // Add log entry to collection for writing. Multiple log entries can be added. 
  
 IEnumerable<LogEntry> 
  
 logEntries 
  
 = 
  
 new 
  
  LogEntry 
 
 [] 
  
 { 
  
 logEntry 
  
 }; 
  
 // Write new log entry. 
  
 client 
 . 
 WriteLogEntries 
 ( 
 logName 
 , 
  
 resource 
 , 
  
 entryLabels 
 , 
  
 logEntries 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 "Log Entry created." 
 ); 
  
 } 
  
 } 
 } 
 

  // Sample logging-quickstart writes a log entry to Cloud Logging. 
 package 
  
 main 
 import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "log" 
  
 "cloud.google.com/go/logging" 
 ) 
 func 
  
 main 
 () 
  
 { 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 // Sets your Google Cloud Platform project ID. 
  
 projectID 
  
 := 
  
 "YOUR_PROJECT_ID" 
  
 // Creates a client. 
  
 client 
 , 
  
 err 
  
 := 
  
 logging 
 . 
 NewClient 
 ( 
 ctx 
 , 
  
 projectID 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 log 
 . 
 Fatalf 
 ( 
 "Failed to create client: %v" 
 , 
  
 err 
 ) 
  
 } 
  
 // Sets the name of the log to write to. 
  
 logName 
  
 := 
  
 "my-log" 
  
 // Selects the log to write to. 
  
 logger 
  
 := 
  
 client 
 . 
 Logger 
 ( 
 logName 
 ) 
  
 // Sets the data to log. 
  
 text 
  
 := 
  
 "Hello, world!" 
  
 // Adds an entry to the log buffer. 
  
 logger 
 . 
  Log 
 
 ( 
 logging 
 . 
  Entry 
 
 { 
 Payload 
 : 
  
 text 
 }) 
  
 // Closes the client and flushes the buffer to the Cloud Logging 
  
 // service. 
  
 if 
  
 err 
  
 := 
  
 client 
 . 
 Close 
 (); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 log 
 . 
 Fatalf 
 ( 
 "Failed to close client: %v" 
 , 
  
 err 
 ) 
  
 } 
  
 fmt 
 . 
 Printf 
 ( 
 "Logged: %v\n" 
 , 
  
 text 
 ) 
 } 
 

  import 
  
 com.google.cloud. MonitoredResource 
 
 ; 
 import 
  
 com.google.cloud.logging. LogEntry 
 
 ; 
 import 
  
 com.google.cloud.logging. Logging 
 
 ; 
 import 
  
 com.google.cloud.logging. LoggingOptions 
 
 ; 
 import 
  
 com.google.cloud.logging. Payload 
.StringPayload 
 ; 
 import 
  
 com.google.cloud.logging. Severity 
 
 ; 
 import 
  
 java.util.Collections 
 ; 
 /** 
 * This sample demonstrates writing logs using the Cloud Logging API. The library also offers a 
 * java.util.logging Handler `com.google.cloud.logging.LoggingHandler` Logback integration is also 
 * available : 
 * https://github.com/googleapis/google-cloud-java/tree/master/google-cloud-clients/google-cloud-contrib/google-cloud-logging-logback 
 * Using the java.util.logging handler / Logback appender should be preferred to using the API 
 * directly. 
 */ 
 public 
  
 class 
 QuickstartSample 
  
 { 
  
 /** Expects a new or existing Cloud log name as the first argument. */ 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
  String 
 
 ... 
  
 args 
 ) 
  
 throws 
  
 Exception 
  
 { 
  
 // The name of the log to write to 
  
  String 
 
  
 logName 
  
 = 
  
 args 
 [ 
 0 
 ] 
 ; 
  
 // "my-log"; 
  
  String 
 
  
 textPayload 
  
 = 
  
 "Hello, world!" 
 ; 
  
 // Instantiates a client 
  
 try 
  
 ( 
  Logging 
 
  
 logging 
  
 = 
  
  LoggingOptions 
 
 . 
 getDefaultInstance 
 (). 
 getService 
 ()) 
  
 { 
  
  LogEntry 
 
  
 entry 
  
 = 
  
  LogEntry 
 
 . 
 newBuilder 
 ( 
 StringPayload 
 . 
 of 
 ( 
 textPayload 
 )) 
  
 . 
 setSeverity 
 ( 
  Severity 
 
 . 
 ERROR 
 ) 
  
 . 
 setLogName 
 ( 
 logName 
 ) 
  
 . 
 setResource 
 ( 
  MonitoredResource 
 
 . 
 newBuilder 
 ( 
 "global" 
 ). 
 build 
 ()) 
  
 . 
 build 
 (); 
  
 // Writes the log entry asynchronously 
  
 logging 
 . 
 write 
 ( 
 Collections 
 . 
 singleton 
 ( 
 entry 
 )); 
  
 // Optional - flush any pending log entries just before Logging is closed 
  
 logging 
 . 
 flush 
 (); 
  
 } 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "Logged: %s%n" 
 , 
  
 textPayload 
 ); 
  
 } 
 } 
 

  // Imports the Google Cloud client library 
 const 
  
 { 
 Logging 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/logging 
' 
 ); 
 async 
  
 function 
  
 quickstart 
 ( 
  
 projectId 
  
 = 
  
 'YOUR_PROJECT_ID' 
 , 
  
 // Your Google Cloud Platform project ID 
  
 logName 
  
 = 
  
 'my-log' 
  
 // The name of the log to write to 
 ) 
  
 { 
  
 // Creates a client 
  
 const 
  
 logging 
  
 = 
  
 new 
  
  Logging 
 
 ({ 
 projectId 
 }); 
  
 // Selects the log to write to 
  
 const 
  
 log 
  
 = 
  
 logging 
 . 
 log 
 ( 
 logName 
 ); 
  
 // The data to write to the log 
  
 const 
  
 text 
  
 = 
  
 'Hello, world!' 
 ; 
  
 // The metadata associated with the entry 
  
 const 
  
 metadata 
  
 = 
  
 { 
  
 resource 
 : 
  
 { 
 type 
 : 
  
 'global' 
 }, 
  
 // See: https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity 
  
 severity 
 : 
  
 ' INFO 
' 
 , 
  
 }; 
  
 // Prepares a log entry 
  
 const 
  
 entry 
  
 = 
  
 log 
 . 
 entry 
 ( 
 metadata 
 , 
  
 text 
 ); 
  
 async 
  
 function 
  
 writeLog 
 () 
  
 { 
  
 // Writes the log entry 
  
 await 
  
 log 
 . 
 write 
 ( 
 entry 
 ); 
  
 console 
 . 
 log 
 ( 
 `Logged: 
 ${ 
 text 
 } 
 ` 
 ); 
  
 } 
  
 writeLog 
 (); 
 } 
 

  # Includes the autoloader for libraries installed with composer 
 require __DIR__ . '/vendor/autoload.php'; 
 # Imports the Google Cloud client library 
 use Google\Cloud\Logging\LoggingClient; 
 # Your Google Cloud Platform project ID 
 $projectId = 'YOUR_PROJECT_ID'; 
 # Instantiates a client 
 $logging = new LoggingClient([ 
 'projectId' => $projectId 
 ]); 
 # Selects the log to write to 
 $logger = $logging->logger('my-log'); 
 # The data to log 
 $text = 'Hello, world!'; 
 # Creates and writes the log entry 
 $entry = $logger->entry($text); 
 $logger->write($entry); 
 echo 'Logged ' . $text; 
 

  # Imports the Google Cloud client library 
 from 
  
 google.cloud 
  
 import 
 logging 
 # Instantiates a client 
 logging_client 
 = 
 logging 
 . 
  Client 
 
 () 
 # The name of the log to write to 
 log_name 
 = 
 "my-log" 
 # Selects the log to write to 
 logger 
 = 
 logging_client 
 . 
  logger 
 
 ( 
 log_name 
 ) 
 # The data to log 
 text 
 = 
 "Hello, world!" 
 # Writes the log entry 
 logger 
 . 
 log_text 
 ( 
 text 
 ) 
 print 
 ( 
 "Logged: 
 {} 
 " 
 . 
 format 
 ( 
 text 
 )) 
 

  # Imports the Google Cloud client library 
 require 
  
 "google/cloud/logging" 
 # Instantiates a client 
 logging 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  Logging 
 
 . 
  new 
 
 # Prepares a log entry 
 entry 
  
 = 
  
 logging 
 . 
  entry 
 
 # payload = "The data you want to log" 
 entry 
 . 
  payload 
 
  
 = 
  
 payload 
 # log_name = "The name of the log to write to" 
 entry 
 . 
 log_name 
  
 = 
  
 log_name 
 # The resource associated with the data 
 entry 
 . 
 resource 
 . 
 type 
  
 = 
  
 "global" 
 # Writes the log entry 
 logging 
 . 
 write_entries 
  
 entry 
 puts 
  
 "Logged 
 #{ 
 entry 
 . 
  payload 
 
 } 
 "