This is the definition of the HandlerOptions for func NewOtelHandler(loggerProvider otel.LoggerProvider, opts *HandlerOptions) *OtelHandler {

Which means that you cannot set the level since its unexported :/

type HandlerOptions struct {
	level slog.Leveler
}

https://github.com/agoda-com/opentelemetry-go/blob/main/otelslog/otel_handler.go#L42

Feature request

support grpc exporter regarding SDK specification https://opentelemetry.io/docs/concepts/sdk-configuration/otlp-exporter-configuration/#otel_exporter_otlp_protocol

Hi,
Thanks for sharing and maintaining this repo.

When I use the autoconfigure package, I get these errors in my console:

2023/10/10 13:51:17 internal_logging.go:58: "msg"="Can't instantiate otlp exporter" "error"=null

I checked the code, and it seems that this line (along with the one for the logging exporter here) are emitting errors even when err is nil. my sdk setup is able to export log records successfully even with this console error.

I hope I am not missing something obvious, but should these prints be wrapped in an if statement? and should the code skip executing cfg.processors = append(cfg.processors, sdk.NewBatchLogRecordProcessor(otlpExporter)) in case of an error in otlplogs.NewExporter(ctx)?

Follow up for #21

Bug report

Describe the bug

During log transformation Logger/Exporter Resource Attributes should be as resource attributes and log attributes from instrumentation should be exported as scope attributes

Currently both exporter resource and logger instrumentation resources merged as scope resources and exported as Resource Logs, however Exporter don't have information about LoggerProvider resources to separate ResourceLogs from ScopeResources.

The current implementation only accept strings for the Body of the implementation.

The Open Telemetry Log Model specification calls for the body to accept the any type.

Feature request

It is nice to have OTEL_LOGS_EXPORTER=stdout with stdout logs output. Usually it helps for debugging.
see env configuration https://opentelemetry.io/docs/concepts/sdk-configuration/general-sdk-configuration/#otel_logs_exporter

Feature request

Support http/json export for logs regarding https://opentelemetry.io/docs/concepts/sdk-configuration/otlp-exporter-configuration/#otel_exporter_otlp_protocol

Type

• - Enhancement - completely new feature
• - Improvement - make what we have better

Is your feature request related to a problem?

Implement SDK specification https://opentelemetry.io/docs/concepts/sdk-configuration/otlp-exporter-configuration/#otel_exporter_otlp_protocol

On the code example in README.md

Question

The code example in README.md has
otel.SetLoggerProvider(loggerProvider)
but the function is
[func SetLogger(logger logr.Logger)](https://pkg.go.dev/go.opentelemetry.io/otel#SetLogger)

Suggestion (Optional)

Consider changing the example.

Thank you for putting this package together. I think it's a really valuable addition to the ecosystem's support of OpenTelemetry. One gap, however, is that there is no way to easily redirect stdout/stderr to the Otel collector as well. One vital part of maintaining a production application is seeing any unintended errors or panics that occur.

Third party libraries also often use fmt.Println, etc which prints to stderr. This is resulting in my application sending nicely formatted logs to the collector, but then occasionally key details on an unexpected error get lost. In the case of a panic, it is easy enough to recover(); however, not having third party logs get sent to my logging platform has the potentialy to create confusion. Any ideas on how this will likely be handled by the Go community and this library?

We are currently doing something like this:

// logging package
func RedirectStdOut(writer io.Writer) func() {
	old := os.Stdout

	r, w, err := os.Pipe()
	if err != nil {
		panic(err)
	}

	os.Stdout = w

	go func() {
		if _, err := io.Copy(writer, r); err != nil {
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
			panic(err)
		}
	}()

	return func() {
		w.Close()
		os.Stdout = old
	}
}

func RedirectStdErr(writer io.Writer) func() {
	old := os.Stderr

	r, w, err := os.Pipe()
	if err != nil {
		panic(err)
	}

	os.Stderr = w

	go func() {
		if _, err := io.Copy(writer, r); err != nil {
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
			panic(err)
		}
	}()

	return func() {
		w.Close()
		os.Stderr = old
	}
}

// When instantiating the logger
func redirectStdLog() func() {
	// redirect std out and std err to the new slog logger
	sw := logging.NewSlogWriter(slog.Default())

	restoreErr := logging.RedirectStdErr(sw)
	restoreOut := logging.RedirectStdOut(sw)

	return func() {
		sw.Close()
		restoreErr()
		restoreOut()

		if otelShutdown != nil {
			err := otelShutdown(context.Background())
			if err != nil {
				panic(err)
			}
		}
	}
}

We have also thought about wrapping the execution of our application in another Go program that reads all of the stdout/stdin from the running application and pipes it to OpenTelemetry. Any thoughts?