Add core package with logger. (#4)

## What changes are proposed in this pull request?

This PR adds a new `core` package with the `Logger` interface. The
interface is a simplified version of the interface used in the legacy
SDK. It is meant to be used by all other modular clients.

## How is this tested?

Complete test coverage.

Author: renaudhartert-db

core/README.md

@@ -0,0 +1 @@
+# Databricks Core

core/go.mod

@@ -0,0 +1,3 @@
+module github.com/databricks/sdk-go/core
+
+go 1.25.4

core/log/log.go

@@ -0,0 +1,61 @@
+// Package log provides the Databricks Logger interface and a default logger
+// implementation.
+//
+// The Logger interface is designed to log messages at different levels of
+// severity. When creating a logger, you can set a minimum log level, meaning
+// any messages below this level will be ignored.
+package log
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+)
+
+// Level represents the importance or severity of a log event. The higher the
+// level, the more important or severe that event is.
+type Level int
+
+const (
+	LevelTrace Level = -8
+	LevelDebug Level = -4
+	LevelInfo  Level = 0
+	LevelWarn  Level = 4
+	LevelError Level = 8
+)
+
+func (l Level) String() string {
+	switch l {
+	case LevelTrace:
+		return "TRACE"
+	case LevelDebug:
+		return "DEBUG"
+	case LevelInfo:
+		return "INFO"
+	case LevelWarn:
+		return "WARN"
+	case LevelError:
+		return "ERROR"
+	default:
+		return "UNKNOWN"
+	}
+}
+
+// Logger is anything that can log a message at a given level.
+type Logger interface {
+	Log(ctx context.Context, level Level, format string, a ...any)
+}
+
+// NewLogger returns a new default logger that logs on [os.Stderr].
+func NewLogger() Logger {
+	return &logger{out: os.Stderr}
+}
+
+type logger struct {
+	out io.Writer
+}
+
+func (l *logger) Log(_ context.Context, level Level, format string, a ...any) {
+	fmt.Fprintf(l.out, "[%s] %s\n", level.String(), fmt.Sprintf(format, a...))
+}

core/log/log_test.go

@@ -0,0 +1,88 @@
+package log
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"testing"
+)
+
+func TestLevel_order(t *testing.T) {
+	var wantOrder = []Level{
+		LevelTrace,
+		LevelDebug,
+		LevelInfo,
+		LevelWarn,
+		LevelError,
+	}
+
+	for i := 1; i < len(wantOrder); i++ {
+		if wantOrder[i-1] >= wantOrder[i] {
+			t.Errorf("Level %s should be lower than %s", wantOrder[i-1].String(), wantOrder[i].String())
+		}
+	}
+}
+
+func TestLogger_Log(t *testing.T) {
+	testCases := []struct {
+		level  Level
+		format string
+		args   []any
+		want   string
+	}{
+		{
+			level:  LevelTrace,
+			format: "test %s",
+			args:   []any{"message"},
+			want:   "[TRACE] test message\n",
+		},
+		{
+			level:  LevelDebug,
+			format: "test %s",
+			args:   []any{"message"},
+			want:   "[DEBUG] test message\n",
+		},
+		{
+			level:  LevelInfo,
+			format: "test %s",
+			args:   []any{"message"},
+			want:   "[INFO] test message\n",
+		},
+		{
+			level:  LevelWarn,
+			format: "test %s",
+			args:   []any{"message"},
+			want:   "[WARN] test message\n",
+		},
+		{
+			level:  LevelError,
+			format: "test %s",
+			args:   []any{"message"},
+			want:   "[ERROR] test message\n",
+		},
+		{
+			level:  Level(42), // unknown level
+			format: "test %s",
+			args:   []any{"message"},
+			want:   "[UNKNOWN] test message\n",
+		},
+	}
+
+	for _, tc := range testCases {
+		out := &bytes.Buffer{}
+		l := logger{out: out}
+
+		l.Log(context.Background(), tc.level, tc.format, tc.args...)
+
+		if got := out.String(); got != tc.want {
+			t.Errorf("Log(): got %s, want %s", got, tc.want)
+		}
+	}
+}
+
+func TestNew(t *testing.T) {
+	l := NewLogger().(*logger)
+	if l.out != os.Stderr {
+		t.Errorf("NewLogger() got out %v, want %v", l.out, os.Stderr)
+	}
+}

go.work

@@ -2,5 +2,6 @@ go 1.25.4
 
 use (
     ./auth
+    ./core
     ./databricks
 )