feat!: ship v1 release with simplified APIs

Author: KimMachineGun

README.md

@@ -10,11 +10,7 @@ See more details about `GOMEMLIMIT` [here](https://tip.golang.org/doc/gc-guide#M
 
 ## Notice
 
-Version `v0.5.0` introduces a fallback to system memory limits as an experimental feature when cgroup limits are unavailable. Activate this by setting `AUTOMEMLIMIT_EXPERIMENT=system`.
-You can also use system memory limits via `memlimit.FromSystem` provider directly.
-
-This feature is under evaluation and might become a default or be removed based on user feedback.
-If you have any feedback about this feature, please open an issue.
+Version `v1.0.0` introduces breaking changes to simplify the API. The library now provides a single `memlimit.Set` function, and system memory limits are used automatically as a fallback when cgroup limits are unavailable.
 
 ## Installation
 
@@ -28,40 +24,44 @@ go get github.com/KimMachineGun/automemlimit@latest
 package main
 
 // By default, it sets `GOMEMLIMIT` to 90% of cgroup's memory limit.
-// This is equivalent to `memlimit.SetGoMemLimitWithOpts(memlimit.WithLogger(slog.Default()))`
-// To disable logging, use `memlimit.SetGoMemLimitWithOpts` directly.
+// System memory is used as a fallback if cgroup is not available.
 import _ "github.com/KimMachineGun/automemlimit"
 ```
 
+> **Note:** The automatic system-memory fallback applies only when you use the convenience import shown above. Calling `memlimit.Set` directly defaults to the cgroup provider; add an explicit fallback if you need it.
+
 or
 
 ```go
 package main
 
-import "github.com/KimMachineGun/automemlimit/memlimit"
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"github.com/KimMachineGun/automemlimit/memlimit"
+)
 
-func init() {
-	memlimit.SetGoMemLimitWithOpts(
+func main() {
+	// Set GOMEMLIMIT to 90% of cgroup's memory limit (no automatic fallback)
+	memlimit.Set()
+
+	// With explicit system memory fallback
+	memlimit.Set(
+		memlimit.WithProvider(
+			memlimit.ApplyFallback(memlimit.FromCgroup, memlimit.FromSystem),
+		),
 		memlimit.WithRatio(0.9),
-		memlimit.WithProvider(memlimit.FromCgroup),
 		memlimit.WithLogger(slog.Default()),
-		memlimit.WithRefreshInterval(1*time.Minute),
 	)
-	memlimit.SetGoMemLimitWithOpts(
-		memlimit.WithRatio(0.9),
-		memlimit.WithProvider(
-			memlimit.ApplyFallback(
-				memlimit.FromCgroup,
-				memlimit.FromSystem,
-			),
-		),
-		memlimit.WithRefreshInterval(1*time.Minute),
+
+	// With refresh interval
+	refreshCtx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	memlimit.Set(
+		memlimit.WithRefreshInterval(refreshCtx, 1*time.Minute),
 	)
-	memlimit.SetGoMemLimit(0.9)
-	memlimit.SetGoMemLimitWithProvider(memlimit.Limit(1024*1024), 0.9)
-	memlimit.SetGoMemLimitWithProvider(memlimit.FromCgroup, 0.9)
-	memlimit.SetGoMemLimitWithProvider(memlimit.FromCgroupV1, 0.9)
-	memlimit.SetGoMemLimitWithProvider(memlimit.FromCgroupHybrid, 0.9)
-	memlimit.SetGoMemLimitWithProvider(memlimit.FromCgroupV2, 0.9)
 }
 ```

automemlimit.go

@@ -7,7 +7,13 @@ import (
 )
 
 func init() {
-	memlimit.SetGoMemLimitWithOpts(
+	memlimit.Set(
+		memlimit.WithProvider(
+			memlimit.ApplyFallback(
+				memlimit.FromCgroup,
+				memlimit.FromSystem,
+			),
+		),
 		memlimit.WithLogger(slog.Default()),
 	)
 }

examples/dynamic/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"errors"
 	"log/slog"
 	"os"
@@ -15,11 +16,12 @@ import (
 func init() {
 	slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stderr, nil)))
 
-	memlimit.SetGoMemLimitWithOpts(
+	refreshCtx := context.Background()
+	memlimit.Set(
 		memlimit.WithProvider(
 			FileProvider("limit.txt"),
 		),
-		memlimit.WithRefreshInterval(5*time.Second),
+		memlimit.WithRefreshInterval(refreshCtx, 5*time.Second),
 		memlimit.WithLogger(slog.Default()),
 	)
 }
@@ -37,7 +39,7 @@ func FileProvider(path string) memlimit.Provider {
 		b, err := os.ReadFile(path)
 		if err != nil {
 			if errors.Is(err, os.ErrNotExist) {
-				return memlimit.ApplyFallback(memlimit.FromCgroup, memlimit.FromSystem)()
+				return memlimit.FromCgroup()
 			}
 			return 0, err
 		}

examples/logger/main.go

@@ -8,10 +8,7 @@ import (
 )
 
 func init() {
-	memlimit.SetGoMemLimitWithOpts(
-		memlimit.WithProvider(
-			memlimit.Limit(1024*1024*1024),
-		),
+	memlimit.Set(
 		memlimit.WithLogger(slog.New(slog.NewJSONHandler(os.Stderr, nil))),
 	)
 }

examples/system/main.go

@@ -1,11 +1,9 @@
 package main
 
-import (
-	"github.com/KimMachineGun/automemlimit/memlimit"
-)
+import "github.com/KimMachineGun/automemlimit/memlimit"
 
 func init() {
-	memlimit.SetGoMemLimitWithOpts(
+	memlimit.Set(
 		memlimit.WithProvider(
 			memlimit.ApplyFallback(
 				memlimit.FromCgroup,

memlimit/cgroups_test.go

@@ -83,8 +83,8 @@ func TestParseMountInfoLine(t *testing.T) {
 			},
 		},
 		{
-			name:    "super options have spaces (issue #28)",
-			input:   `1391 1160 0:151 / /Docker/host rw,noatime - 9p C:\134Program\040Files\134Docker\134Docker\134resources rw,dirsync,aname=drvfs;path=C:\Program Files\Docker\Docker\resources;symlinkroot=/mnt/,mmap,access=client,msize=65536,trans=fd,rfd=3,wfd=3`,
+			name:  "super options have spaces (issue #28)",
+			input: `1391 1160 0:151 / /Docker/host rw,noatime - 9p C:\134Program\040Files\134Docker\134Docker\134resources rw,dirsync,aname=drvfs;path=C:\Program Files\Docker\Docker\resources;symlinkroot=/mnt/,mmap,access=client,msize=65536,trans=fd,rfd=3,wfd=3`,
 			want: mountInfo{
 				Root:           "/",
 				MountPoint:     "/Docker/host",

memlimit/experiment.go

@@ -5,9 +5,18 @@ import (
 	"log/slog"
 )
 
-type noopLogger struct{}
+var _ slog.Handler = discardHandler{}
 
-func (noopLogger) Enabled(context.Context, slog.Level) bool  { return false }
-func (noopLogger) Handle(context.Context, slog.Record) error { return nil }
-func (d noopLogger) WithAttrs([]slog.Attr) slog.Handler      { return d }
-func (d noopLogger) WithGroup(string) slog.Handler           { return d }
+type discardHandler struct{}
+
+func (discardHandler) Enabled(context.Context, slog.Level) bool  { return false }
+func (discardHandler) Handle(context.Context, slog.Record) error { return nil }
+func (dh discardHandler) WithAttrs([]slog.Attr) slog.Handler     { return dh }
+func (dh discardHandler) WithGroup(string) slog.Handler          { return dh }
+
+func memlimitLogger(logger *slog.Logger) *slog.Logger {
+	if logger == nil {
+		return slog.New(discardHandler{})
+	}
+	return logger.With(slog.String("package", "github.com/KimMachineGun/automemlimit/memlimit"))
+}