feat!: simplify v1 API and harden cgroup detection

Author: KimMachineGun

README.md

@@ -10,11 +10,16 @@ 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.
+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:
+- `SetGoMemLimitWithOpts`, `SetGoMemLimit`, `SetGoMemLimitWithProvider`, `SetGoMemLimitWithEnv` removed. Use `Set` instead
+- `FromCgroupV1`, `FromCgroupV2`, `FromCgroupHybrid` removed. Use `FromCgroup` instead
+- `WithEnv`, `AUTOMEMLIMIT_EXPERIMENT`, and `AUTOMEMLIMIT_DEBUG` removed
+- `import _ "github.com/KimMachineGun/automemlimit"` now enables system memory fallback by default
+- `memlimit.Set` uses cgroup memory by default. Configure `FromSystem` as a fallback to match the blank import behavior
+- `WithMin` added to set a minimum `GOMEMLIMIT`
+- `WithRefreshInterval` now takes a `context.Context` to control the refresh goroutine
 
 ## Installation
 
@@ -27,41 +32,33 @@ 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.
+// 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.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,11 @@
+// Package automemlimit provides automatic GOMEMLIMIT configuration.
+//
+// Importing this package sets GOMEMLIMIT automatically with system memory
+// fallback enabled.
+//
+//	import _ "github.com/KimMachineGun/automemlimit"
+//
+// For more control, use the memlimit package directly.
 package automemlimit
 
 import (
@@ -7,7 +15,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,24 +14,25 @@ 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"),
 		),
-		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 {

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() {}