feat(go): add logs page

Author: giortzisg

docs/platforms/go/common/logs/index.mdx

@@ -0,0 +1,143 @@
+---
+title: Set Up Logs
+sidebar_title: Logs
+description: "Structured logs allow you to send, view and query logs sent from your applications within Sentry."
+sidebar_order: 5600
+---
+
+<Include name="feature-stage-beta-logs.mdx" />
+
+With Sentry Structured Logs, you can send text based log information from your applications to Sentry. Once in Sentry, these logs can be viewed alongside relevant errors, searched by text-string, or searched using their individual attributes.
+
+## Requirements
+
+Logs in Go are supported in Sentry Go SDK version `0.33.0` and above.
+
+## Setup
+
+To enable logging, you need to initialize the SDK with the `EnableLogs` option set to true.
+
+```go
+package main
+
+import (
+	"context"
+	"github.com/getsentry/sentry-go"
+	"time"
+)
+
+func main() {
+  if err := sentry.Init(sentry.ClientOptions{
+    Dsn:        "___PUBLIC_DSN___",
+    EnableLogs: true,
+	}); err != nil {
+  	fmt.Printf("Sentry initialization failed: %v\n", err)
+  }
+  // Flush buffered events before the program terminates.
+  // Set the timeout to the maximum duration the program can afford to wait.
+  defer sentry.Flush(2 * time.Second)
+}
+```
+
+## Usage
+
+Once the feature is enabled on the SDK and the SDK is initialized, you can send logs by using
+the `sentry.Logger` API.
+
+The `Sentry.Logger` API exposes methods that support six different log levels: `trace`,
+ `debug`, `info`, `warn`, `error` and `fatal`. The methods support both `fmt.Print` and `fmt.Println` like syntax. Using
+ these methods is as simple as:
+
+```go
+ctx := context.Background()
+logger := sentry.NewLogger(ctx)
+
+// You can use the logger like [fmt.Print]
+logger.Info(ctx, "Hello ", "world!")
+// Or like [fmt.Printf]
+logger.Infof(ctx, "Hello %v!", "world")
+```
+Additionally, you can attach properties to each log entry using the `attribute` API. These properties will be sent
+to Sentry, and can be searched from within the Logs UI, and even added to the Logs views as a dedicated column.
+
+```go
+package main
+
+import (
+	"context"
+	"github.com/getsentry/sentry-go"
+	"github.com/getsentry/sentry-go/attribute"
+	"time"
+)
+
+func main() {
+	err := sentry.Init(sentry.ClientOptions{
+		Dsn:        "___PUBLIC_DSN___",
+		EnableLogs: true,
+	})
+	if err != nil {
+		panic(err)
+	}
+	defer sentry.Flush(2 * time.Second)
+
+	ctx := context.Background()
+	logger := sentry.NewLogger(ctx)
+
+	logger.SetAttributes(
+		attribute.Int("key.int", 42),
+		attribute.Bool("key.boolean", true),
+		attribute.Float64("key.float", 42.4),
+		attribute.String("key.string", "string"),
+	)
+	logger.Warnf(ctx, "I have params: %v and attributes", "example param")
+}
+```
+Currently the `attribute` API supports only these value types: `int`, `string`, `bool` and `float`.
+
+## Integrations
+
+The `sentry.Logger` implements the `io.Writer` interface, so you can easily inject the logger into your existing setup.
+
+```go
+sentryLogger := sentry.NewLogger(ctx)
+logger := log.New(sentryLogger, "", log.LstdFlags)
+logger.Println("Implementing log.Logger")
+
+slogger := slog.New(slog.NewJSONHandler(sentryLogger, nil))
+slogger.Info("Implementing slog.Logger")
+```
+
+<Alert>
+However in order to properly attach the correct Spans with each Log entry, a `context.Context` is required. The `Write` function of
+the `io.Writer` interface does not provide `context` so currently wrapping the custom logger will provide limited functionality.
+The recommended way is to use the `sentry.Logger` itself.
+</Alert>
+
+## Options
+
+### BeforeSendLog
+
+To filter logs, or update them before they are sent to Sentry, you can use the `BeforeSendLog` client option.
+```go
+if err := sentry.Init(sentry.ClientOptions{
+  Dsn:        "___PUBLIC_DSN___",
+  EnableLogs: true,
+  BeforeSendLog: func(log *Log) *Log {
+    // filter out all trace logs
+    if log.Level == sentry.LogLevelTrace {
+      return nil
+    }
+
+    // filter all logs below warning
+    if log.Severity <= LogSeverityInfo {
+      return nil
+    }
+  },
+}); err != nil {
+  fmt.Printf("Sentry initialization failed: %v\n", err)
+}
+```
+
+### Debug
+
+If debug is set to true, calls to the logger will also print to the console with the appropriate log level.