feat!: simplify v1 API and harden cgroup detection

Author: KimMachineGun

README.md

@@ -4,17 +4,23 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/KimMachineGun/automemlimit)](https://goreportcard.com/report/github.com/KimMachineGun/automemlimit)
 [![Test](https://github.com/KimMachineGun/automemlimit/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/KimMachineGun/automemlimit/actions/workflows/test.yml)
 
-Automatically set `GOMEMLIMIT` to match Linux [cgroups(7)](https://man7.org/linux/man-pages/man7/cgroups.7.html) memory limit.
+Automatically set `GOMEMLIMIT` based on the Linux [cgroups(7)](https://man7.org/linux/man-pages/man7/cgroups.7.html) memory limit.
 
 See more details about `GOMEMLIMIT` [here](https://tip.golang.org/doc/gc-guide#Memory_limit).
 
 ## 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.
+Version `v1.0.0` simplifies the public API and improves cgroup memory limit detection.
 
-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.
+Key changes from v0.x:
+- `memlimit.Set` replaces `memlimit.SetGoMemLimitWithOpts`, `memlimit.SetGoMemLimit`, `memlimit.SetGoMemLimitWithProvider`, and `memlimit.SetGoMemLimitWithEnv`
+- `memlimit.Set` returns the previous `GOMEMLIMIT` instead of 0 when it skips configuration or returns an error
+- `memlimit.FromCgroup` replaces `memlimit.FromCgroupV1`, `memlimit.FromCgroupV2`, and `memlimit.FromCgroupHybrid`
+- `memlimit.WithEnv`, `AUTOMEMLIMIT_EXPERIMENT`, and `AUTOMEMLIMIT_DEBUG` were removed
+- `import _ "github.com/KimMachineGun/automemlimit"` now falls back to system memory by default
+- `memlimit.WithMin` sets a lower bound for `GOMEMLIMIT`
+- `memlimit.Set` now handles `memlimit.ErrNoLimit` by setting `GOMEMLIMIT` to `math.MaxInt64`
+- `memlimit.WithRefreshInterval` now requires a `context.Context` that can be canceled to stop the refresh goroutine
 
 ## Installation
 
@@ -27,41 +33,34 @@ go get github.com/KimMachineGun/automemlimit@latest
 ```go
 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.
+// Importing this package sets GOMEMLIMIT automatically with system memory fallback enabled.
 import _ "github.com/KimMachineGun/automemlimit"
 ```
 
-or
+For more control, use `memlimit.Set` directly:
 
 ```go
 package main
 
-import "github.com/KimMachineGun/automemlimit/memlimit"
+import (
+	"log"
 
-func init() {
-	memlimit.SetGoMemLimitWithOpts(
-		memlimit.WithRatio(0.9),
-		memlimit.WithProvider(memlimit.FromCgroup),
-		memlimit.WithLogger(slog.Default()),
-		memlimit.WithRefreshInterval(1*time.Minute),
-	)
-	memlimit.SetGoMemLimitWithOpts(
+	"github.com/KimMachineGun/automemlimit/memlimit"
+)
+
+func main() {
+	_, err := memlimit.Set(
 		memlimit.WithRatio(0.9),
+		memlimit.WithMin(100*1024*1024),
 		memlimit.WithProvider(
 			memlimit.ApplyFallback(
 				memlimit.FromCgroup,
 				memlimit.FromSystem,
 			),
 		),
-		memlimit.WithRefreshInterval(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)
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```

automemlimit.go

@@ -1,3 +1,8 @@
+// Package automemlimit sets GOMEMLIMIT automatically, falling back to system memory.
+//
+//	import _ "github.com/KimMachineGun/automemlimit"
+//
+// Use the memlimit package directly for more control.
 package automemlimit
 
 import (
@@ -7,7 +12,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,7 +2,9 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"errors"
+	"log"
 	"log/slog"
 	"os"
 	"os/signal"
@@ -12,27 +14,28 @@ import (
 	"github.com/KimMachineGun/automemlimit/memlimit"
 )
 
-func init() {
+func main() {
 	slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stderr, nil)))
 
-	memlimit.SetGoMemLimitWithOpts(
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
+	_, err := memlimit.Set(
 		memlimit.WithProvider(
-			FileProvider("limit.txt"),
+			fileProvider("limit.txt"),
 		),
-		memlimit.WithRefreshInterval(5*time.Second),
+		memlimit.WithRefreshInterval(ctx, 5*time.Second),
 		memlimit.WithLogger(slog.Default()),
 	)
-}
-
-func main() {
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt)
+	if err != nil {
+		log.Fatal(err)
+	}
 
-	s := <-c
-	slog.Info("signal captured", slog.Any("signal", s))
+	<-ctx.Done()
+	slog.Info("shutdown")
 }
 
-func FileProvider(path string) memlimit.Provider {
+func fileProvider(path string) memlimit.Provider {
 	return func() (uint64, error) {
 		b, err := os.ReadFile(path)
 		if err != nil {

examples/logger/main.go

@@ -1,19 +1,21 @@
 package main
 
 import (
+	"log"
 	"log/slog"
 	"os"
 
 	"github.com/KimMachineGun/automemlimit/memlimit"
 )
 
-func init() {
-	memlimit.SetGoMemLimitWithOpts(
+func main() {
+	_, err := memlimit.Set(
 		memlimit.WithProvider(
 			memlimit.Limit(1024*1024*1024),
 		),
 		memlimit.WithLogger(slog.New(slog.NewJSONHandler(os.Stderr, nil))),
 	)
+	if err != nil {
+		log.Fatal(err)
+	}
 }
-
-func main() {}

examples/system/main.go

@@ -1,18 +1,21 @@
 package main
 
 import (
+	"log"
+
 	"github.com/KimMachineGun/automemlimit/memlimit"
 )
 
-func init() {
-	memlimit.SetGoMemLimitWithOpts(
+func main() {
+	_, err := memlimit.Set(
 		memlimit.WithProvider(
 			memlimit.ApplyFallback(
 				memlimit.FromCgroup,
 				memlimit.FromSystem,
 			),
 		),
 	)
+	if err != nil {
+		log.Fatal(err)
+	}
 }
-
-func main() {}