func main() {
if len(os.Args) == 2 {
usage("Missing command.")
}
if len(os.Args) != 3 {
usage("")
}
projID := os.Args[1]
command := os.Args[2]
// [START setup]
ctx := context.Background()
client, err := logging.NewClient(ctx, projID)
if err != nil {
log.Fatalf("Failed to create logging client: %v", err)
}
adminClient, err := logadmin.NewClient(ctx, projID)
if err != nil {
log.Fatalf("Failed to create logadmin client: %v", err)
}
client.OnError = func(err error) {
// Print an error to the local log.
// For example, if Flush() failed.
log.Printf("client.OnError: %v", err)
}
// [END setup]
switch command {
case "write":
log.Print("Writing some log entries.")
writeEntry(client)
structuredWrite(client)
case "read":
log.Print("Fetching and printing log entries.")
entries, err := getEntries(adminClient, projID)
if err != nil {
log.Fatalf("Could not get entries: %v", err)
}
log.Printf("Found %d entries.", len(entries))
for _, entry := range entries {
fmt.Printf("Entry: %6s @%s: %v\n",
entry.Severity,
entry.Timestamp.Format(time.RFC3339),
entry.Payload)
}
case "delete":
log.Print("Deleting log.")
if err := deleteLog(adminClient); err != nil {
log.Fatalf("Could not delete log: %v", err)
}
default:
usage("Unknown command.")
}
}
func TestSimplelog(t *testing.T) {
tc := testutil.SystemTest(t)
ctx := context.Background()
client, err := logging.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatalf("logging.NewClient: %v", err)
}
adminClient, err := logadmin.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatalf("logadmin.NewClient: %v", err)
}
defer func() {
if err := client.Close(); err != nil {
t.Errorf("Close: %v", err)
}
}()
defer func() {
testutil.Retry(t, 10, time.Second, func(r *testutil.R) {
if err := deleteLog(adminClient); err != nil {
r.Errorf("deleteLog: %v", err)
}
})
}()
client.OnError = func(err error) {
t.Errorf("OnError: %v", err)
}
writeEntry(client)
structuredWrite(client)
testutil.Retry(t, 10, time.Second, func(r *testutil.R) {
entries, err := getEntries(adminClient, tc.ProjectID)
if err != nil {
r.Errorf("getEntries: %v", err)
return
}
if got, want := len(entries), 2; got != want {
r.Errorf("len(entries) = %d; want %d", got, want)
return
}
wantContain := map[string]*logging.Entry{
"Anything": entries[0],
"The payload can be any type!": entries[0],
"infolog is a standard Go log.Logger": entries[1],
}
for want, entry := range wantContain {
msg := fmt.Sprintf("%s", entry.Payload)
if !strings.Contains(msg, want) {
r.Errorf("want %q to contain %q", msg, want)
}
}
})
}
func ExampleClient_Entries() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
it := client.Entries(ctx, logadmin.Filter(`logName = "projects/my-project/logs/my-log"`))
_ = it // TODO: iterate using Next or iterator.Pager.
}
func ExampleClient_Sinks() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
it := client.Sinks(ctx)
_ = it // TODO: iterate using Next or iterator.Pager.
}
func ExampleClient_DeleteMetric() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
if err := client.DeleteMetric(ctx, "severe-errors"); err != nil {
// TODO: Handle error.
}
}
func ExampleClient_DeleteLog() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
err = client.DeleteLog(ctx, "my-log")
if err != nil {
// TODO: Handle error.
}
}
func ExampleFilter_timestamp() {
// This example demonstrates how to list the last 24 hours of log entries.
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
oneDayAgo := time.Now().Add(-24 * time.Hour)
t := oneDayAgo.Format(time.RFC3339) // Logging API wants timestamps in RFC 3339 format.
it := client.Entries(ctx, logadmin.Filter(fmt.Sprintf(`timestamp > "%s"`, t)))
_ = it // TODO: iterate using Next or iterator.Pager.
}
func ExampleClient_Metric() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
m, err := client.Metric(ctx, "severe-errors")
if err != nil {
// TODO: Handle error.
}
fmt.Println(m)
}
func ExampleClient_Sink() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
s, err := client.Sink(ctx, "severe-errors-to-gcs")
if err != nil {
// TODO: Handle error.
}
fmt.Println(s)
}
func ExampleNewClient() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
// Use client to manage logs, metrics and sinks.
// Close the client when finished.
if err := client.Close(); err != nil {
// TODO: Handle error.
}
}
func ExampleClient_UpdateMetric() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
err = client.UpdateMetric(ctx, &logadmin.Metric{
ID: "severe-errors",
Description: "entries at high severities",
Filter: "severity > ERROR",
})
if err != nil {
// TODO: Handle error.
}
}
func ExampleClient_UpdateSink() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
sink, err := client.UpdateSink(ctx, &logadmin.Sink{
ID: "severe-errors-to-gcs",
Destination: "storage.googleapis.com/my-other-bucket",
Filter: "severity >= ERROR",
})
if err != nil {
// TODO: Handle error.
}
fmt.Println(sink)
}
func main() {
if len(os.Args) == 2 {
usage("Missing command.")
}
if len(os.Args) != 3 {
usage("")
}
projID := os.Args[1]
command := os.Args[2]
// [START create_logging_client]
ctx := context.Background()
client, err := logadmin.NewClient(ctx, projID)
if err != nil {
log.Fatalf("logadmin.NewClient: %v", err)
}
// [END create_logging_client]
switch command {
case "list":
log.Print("Listing log sinks.")
sinks, err := listSinks(client)
if err != nil {
log.Fatalf("Could not list log sinks: %v", err)
}
for _, sink := range sinks {
fmt.Printf("Sink: %v\n", sink)
}
case "create":
if err := createSink(client); err != nil {
log.Fatalf("Could not create sink: %v", err)
}
case "update":
if err := updateSink(client); err != nil {
log.Fatalf("Could not update sink: %v", err)
}
case "delete":
if err := deleteSink(client); err != nil {
log.Fatalf("Could not delete sink: %v", err)
}
default:
usage("Unknown command.")
}
}
func ExampleSinkIterator_Next() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
it := client.Sinks(ctx)
for {
sink, err := it.Next()
if err == iterator.Done {
break
}
if err != nil {
// TODO: Handle error.
}
fmt.Println(sink)
}
}
func ExampleResourceDescriptorIterator_Next() {
ctx := context.Background()
client, err := logadmin.NewClient(ctx, "my-project")
if err != nil {
// TODO: Handle error.
}
it := client.ResourceDescriptors(ctx)
for {
rdesc, err := it.Next()
if err == iterator.Done {
break
}
if err != nil {
// TODO: Handle error.
}
fmt.Println(rdesc)
}
}
func ExampleClient_Entries_pagination() {
// This example demonstrates how to iterate through items a page at a time
// even if each successive page is fetched by a different process. It is a
// complete web server that displays pages of log entries. To run it as a
// standalone program, rename both the package and this function to "main".
ctx := context.Background()
flag.Parse()
if *projectID == "" {
log.Fatal("-project-id missing")
}
var err error
client, err = logadmin.NewClient(ctx, *projectID)
if err != nil {
log.Fatalf("creating logging client: %v", err)
}
http.HandleFunc("/entries", handleEntries)
log.Print("listening on 8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}
func TestMain(m *testing.M) {
flag.Parse() // needed for testing.Short()
ctx := context.Background()
testProjectID = testutil.ProjID()
errorc = make(chan error, 100)
if testProjectID == "" || testing.Short() {
integrationTest = false
if testProjectID != "" {
log.Print("Integration tests skipped in short mode (using fake instead)")
}
testProjectID = "PROJECT_ID"
clean = func(e *logging.Entry) {
// Remove the insert ID for consistency with the integration test.
e.InsertID = ""
}
addr, err := ltesting.NewServer()
if err != nil {
log.Fatalf("creating fake server: %v", err)
}
logging.SetNow(testNow)
newClients = func(ctx context.Context, projectID string) (*logging.Client, *logadmin.Client) {
conn, err := grpc.Dial(addr, grpc.WithInsecure())
if err != nil {
log.Fatalf("dialing %q: %v", addr, err)
}
c, err := logging.NewClient(ctx, projectID, option.WithGRPCConn(conn))
if err != nil {
log.Fatalf("creating client for fake at %q: %v", addr, err)
}
ac, err := logadmin.NewClient(ctx, projectID, option.WithGRPCConn(conn))
if err != nil {
log.Fatalf("creating client for fake at %q: %v", addr, err)
}
return c, ac
}
} else {
integrationTest = true
clean = func(e *logging.Entry) {
// We cannot compare timestamps, so set them to the test time.
// Also, remove the insert ID added by the service.
e.Timestamp = testNow().UTC()
e.InsertID = ""
}
ts := testutil.TokenSource(ctx, logging.AdminScope)
if ts == nil {
log.Fatal("The project key must be set. See CONTRIBUTING.md for details")
}
log.Printf("running integration tests with project %s", testProjectID)
newClients = func(ctx context.Context, projectID string) (*logging.Client, *logadmin.Client) {
c, err := logging.NewClient(ctx, projectID, option.WithTokenSource(ts))
if err != nil {
log.Fatalf("creating prod client: %v", err)
}
ac, err := logadmin.NewClient(ctx, projectID, option.WithTokenSource(ts))
if err != nil {
log.Fatalf("creating prod client: %v", err)
}
return c, ac
}
}
client, aclient = newClients(ctx, testProjectID)
client.OnError = func(e error) { errorc <- e }
initLogs(ctx)
testFilter = fmt.Sprintf(`logName = "projects/%s/logs/%s"`, testProjectID,
strings.Replace(testLogID, "/", "%2F", -1))
exit := m.Run()
client.Close()
os.Exit(exit)
}