diff --git a/README.md b/README.md
index dd9e53c..1aa2090 100644
--- a/README.md
+++ b/README.md
@@ -22,39 +22,103 @@
 
 [embedmd]:# (example_test.go /import\ / $)
 ```go
-import "moul.io/logman"
+import (
+	"fmt"
+
+	"moul.io/logman"
+)
 
 func Example() {
-	writer, _ := logman.NewWriteCloser("./path/to/logdir/", "my-app")
+	// new log manager
+	manager := logman.Manager{
+		Path:     "./path/to/dir",
+		MaxFiles: 10,
+	}
+
+	/*
+		// cleanup old log files for a specific app name
+		err := manager.GCWithName("my-app")
+		checkErr(err)
+
+		// cleanup old log files for any app sharing this log directory
+		err = manager.GC()
+		checkErr(err)
+	*/
+
+	// list existing log files
+	files, err := manager.Files()
+	checkErr(err)
+	fmt.Println(files)
+
+	// - create an WriteCloser
+	// - automatically delete old log files if it hits a limit
+	writer, err := manager.New("my-app")
+	checkErr(err)
 	defer writer.Close()
-	writer.Write([]byte("hello world!"))
+	writer.Write([]byte("hello world!\n"))
+}
+
+func checkErr(err error) {
+	if err != nil {
+		panic(err)
+	}
 }
 ```
 
 ## Usage
 
-[embedmd]:# (.tmp/godoc.txt txt /FUNCTIONS/ $)
+[embedmd]:# (.tmp/godoc.txt txt /TYPES/ $)
 ```txt
-FUNCTIONS
+TYPES
 
-func LogfileGC(logDir string, max int) error
-func NewWriteCloser(target, kind string) (io.WriteCloser, error)
+type File struct {
+	// Full path.
+	Path string
 
-TYPES
+	// Size in bytes.
+	Size int64
+
+	// Provided name when creating the file.
+	Name string
 
-type Logfile struct {
-	Dir    string
-	Name   string
-	Size   int64
-	Kind   string
-	Time   time.Time
+	// Creation date of the file.
+	Time time.Time
+
+	// Whether it is the most recent log file for the provided app name or not.
 	Latest bool
-	Errs   error `json:"Errs,omitempty"`
+
+	// If there were errors when trying to get info about this file.
+	Errs error `json:"Errs,omitempty"`
 }
+    File defines a log file with metadata.
+
+func (f File) String() string
+
+type Manager struct {
+	// Path is the target directory containing the log files.
+	// Default is '.'.
+	Path string
+
+	// MaxFiles is the maximum number of log files in the directory.
+	// If 0, won't automatically GC based on this criteria.
+	MaxFiles int
+}
+    Manager is a configuration object used to create log files with automatic GC
+    rules.
+
+func (m Manager) Files() ([]File, error)
+    Files returns a list of existing log files.
+
+func (m Manager) New(name string) (io.WriteCloser, error)
+    Create a new log file and perform automatic GC of the old log files if
+    needed.
+
+    The created log file will looks like:
 
-func LogfileList(logDir string) ([]*Logfile, error)
+        <path/to/log/dir>/<name>-<time>.log
 
-func (l Logfile) Path() string
+    Depending on the provided configuration of Manager, an automatic GC will be
+    run automatically.
 
 ```
 
diff --git a/example_test.go b/example_test.go
index 550977a..3365566 100644
--- a/example_test.go
+++ b/example_test.go
@@ -1,9 +1,43 @@
 package logman_test
 
-import "moul.io/logman"
+import (
+	"fmt"
+
+	"moul.io/logman"
+)
 
 func Example() {
-	writer, _ := logman.NewWriteCloser("./path/to/logdir/", "my-app")
+	// new log manager
+	manager := logman.Manager{
+		Path:     "./path/to/dir",
+		MaxFiles: 10,
+	}
+
+	/*
+		// cleanup old log files for a specific app name
+		err := manager.GCWithName("my-app")
+		checkErr(err)
+
+		// cleanup old log files for any app sharing this log directory
+		err = manager.GC()
+		checkErr(err)
+	*/
+
+	// list existing log files
+	files, err := manager.Files()
+	checkErr(err)
+	fmt.Println(files)
+
+	// - create an WriteCloser
+	// - automatically delete old log files if it hits a limit
+	writer, err := manager.New("my-app")
+	checkErr(err)
 	defer writer.Close()
-	writer.Write([]byte("hello world!"))
+	writer.Write([]byte("hello world!\n"))
+}
+
+func checkErr(err error) {
+	if err != nil {
+		panic(err)
+	}
 }
diff --git a/logman.go b/logman.go
index ccdb3fb..a5d6dbb 100644
--- a/logman.go
+++ b/logman.go
@@ -8,84 +8,110 @@ import (
 	"path/filepath"
 	"regexp"
 	"sort"
-	"strings"
 	"time"
 
 	"go.uber.org/multierr"
 	"moul.io/u"
 )
 
-func NewWriteCloser(target, kind string) (io.WriteCloser, error) {
-	var filename string
-	switch {
-	case strings.HasSuffix(target, ".log"): // use the indicated 'path' as filename
-		filename = target
-	default: // automatically create a new file in the 'path' directory following a pattern
-		startTime := time.Now().Format(filePatternDateLayout)
-		filename = filepath.Join(
-			target,
-			fmt.Sprintf("%s-%s.log", kind, startTime),
-		)
-		// run gc
-		{
-			err := LogfileGC(target, 20)
-			if err != nil {
-				return nil, err
-			}
-		}
+// Manager is a configuration object used to create log files with automatic GC rules.
+type Manager struct {
+	// Path is the target directory containing the log files.
+	// Default is '.'.
+	Path string
+
+	// MaxFiles is the maximum number of log files in the directory.
+	// If 0, won't automatically GC based on this criteria.
+	MaxFiles int
+
+	// MaxFilesWithName is the maximum number of log files with the same app name.
+	// If 0, won't automatically GC based on this criteria.
+	// TODO: MaxFilesWithName int
+}
+
+// File defines a log file with metadata.
+type File struct {
+	// Full path.
+	Path string
+
+	// Size in bytes.
+	Size int64
+
+	// Provided name when creating the file.
+	Name string
+
+	// Creation date of the file.
+	Time time.Time
+
+	// Whether it is the most recent log file for the provided app name or not.
+	Latest bool
+
+	// If there were errors when trying to get info about this file.
+	Errs error `json:"Errs,omitempty"`
+}
+
+// Create a new log file and perform automatic GC of the old log files if needed.
+//
+// The created log file will looks like:
+//    <path/to/log/dir>/<name>-<time>.log
+//
+// Depending on the provided configuration of Manager, an automatic GC will be run automatically.
+func (m Manager) New(name string) (io.WriteCloser, error) {
+	// FIXME: validate m.Path
+	// FIXME: validate name
+
+	startTime := time.Now().Format(filePatternDateLayout)
+	filename := filepath.Join(
+		m.Path,
+		fmt.Sprintf("%s-%s.log", name, startTime),
+	)
+
+	// run gc
+	if err := m.gc(); err != nil {
+		return nil, fmt.Errorf("auto GC: %w", err)
 	}
 
+	// create log dif if missing
 	if dir := filepath.Dir(filename); !u.DirExists(dir) {
 		err := os.MkdirAll(dir, 0o711)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("create log dir: %w", err)
 		}
 	}
 
+	// create/open the file and create a WriteCloser
 	var writer io.WriteCloser
 	if u.FileExists(filename) {
 		var err error
 		writer, err = os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("open log file: %q: %w", filename, err)
 		}
 	} else {
 		var err error
 		writer, err = os.Create(filename)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("create log file: %q: %w", filename, err)
 		}
 	}
 
 	return writer, nil
 }
 
-type Logfile struct {
-	Dir    string
-	Name   string
-	Size   int64
-	Kind   string
-	Time   time.Time
-	Latest bool
-	Errs   error `json:"Errs,omitempty"`
-}
-
-func (l Logfile) Path() string {
-	return filepath.Join(l.Dir, l.Name)
-}
-
 const filePatternDateLayout = "2006-01-02T15-04-05.000"
 
 var filePatternRegex = regexp.MustCompile(`(?m)^(.*)-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}.\d{3}).log$`)
 
-func LogfileList(logDir string) ([]*Logfile, error) {
-	files, err := ioutil.ReadDir(logDir)
+// Files returns a list of existing log files.
+func (m Manager) Files() ([]File, error) {
+	dir := m.dir()
+	osFiles, err := ioutil.ReadDir(dir)
 	if err != nil {
 		return nil, err
 	}
 
-	logfiles := []*Logfile{}
-	for _, file := range files {
+	files := []File{}
+	for _, file := range osFiles {
 		sub := filePatternRegex.FindStringSubmatch(file.Name())
 		if sub == nil {
 			continue
@@ -96,43 +122,54 @@ func LogfileList(logDir string) ([]*Logfile, error) {
 			errs = multierr.Append(errs, err)
 		}
 
-		logfiles = append(logfiles, &Logfile{
-			Dir:  logDir,
-			Name: file.Name(),
+		files = append(files, File{
+			Path: filepath.Join(dir, file.Name()),
 			Size: file.Size(),
-			Kind: sub[1],
+			Name: sub[1],
 			Time: t,
 			Errs: errs,
 		})
 	}
 
 	// compute latest
-	if len(logfiles) > 0 {
+	if len(files) > 0 {
 		var maxTime time.Time
-		for _, file := range logfiles {
+		for _, file := range files {
 			if file.Time.After(maxTime) {
 				maxTime = file.Time
 			}
 		}
-		for _, file := range logfiles {
+		for idx, file := range files {
 			if file.Time == maxTime {
-				file.Latest = true
+				files[idx].Latest = true
 			}
 		}
 	}
 
-	return logfiles, nil
+	return files, nil
+}
+
+func (m Manager) dir() string {
+	// FIXME: expand homedir, etc
+	if m.Path == "" {
+		return "."
+	}
+	return m.Path
 }
 
-func LogfileGC(logDir string, max int) error {
-	if !u.DirExists(logDir) {
+func (m Manager) gc() error {
+	dir := m.dir()
+
+	if !u.DirExists(dir) {
 		return nil
 	}
-	files, err := LogfileList(logDir)
+
+	files, err := m.Files()
 	if err != nil {
 		return err
 	}
-	if len(files) < max {
+
+	if len(files) < m.MaxFiles-1 {
 		return nil
 	}
 
@@ -141,11 +178,27 @@ func LogfileGC(logDir string, max int) error {
 	})
 
 	var errs error
-	for i := 0; i < len(files)-max; i++ {
-		err := os.Remove(files[i].Path())
+	for i := 0; i <= len(files)-m.MaxFiles; i++ {
+		err := os.Remove(files[i].Path)
 		if err != nil {
 			errs = multierr.Append(errs, err)
 		}
 	}
 	return errs
 }
+
+/*
+   // GCWithName cleans up old log files matching a specific name.
+   func (m Manager) GCWithName(name string) error {
+	return nil
+	}
+
+   // GC cleans up old log files.
+   func (m Manager) GC() error {
+	return nil
+	}
+*/
+
+func (f File) String() string {
+	return f.Path
+}
diff --git a/logman_test.go b/logman_test.go
index 89b2009..fe746be 100644
--- a/logman_test.go
+++ b/logman_test.go
@@ -13,22 +13,41 @@ import (
 	"moul.io/u"
 )
 
+/* FIXME: various tests
+ *
+ * - input validation
+ * - fs manipulation (empty dir, existing dir)
+ * - GC safety (keep non-log files)
+ * - concurrency
+ */
+
 func TestLogfile(t *testing.T) {
 	// setup volatile directory for the test
 	tempdir, err := ioutil.TempDir("", "logutil-file")
 	require.NoError(t, err)
 	defer os.RemoveAll(tempdir)
 
+	// init logman
+	manager := logman.Manager{
+		Path:     tempdir,
+		MaxFiles: 10,
+	}
+
+	invalidManager := logman.Manager{
+		Path:     filepath.Join(tempdir, "doesnotexist"),
+		MaxFiles: 10,
+	}
+
 	// check loading log files from an invalid directory
 	{
-		files, err := logman.LogfileList(filepath.Join(tempdir, "doesnotexist"))
+		files, err := invalidManager.Files()
 		require.Error(t, err)
 		require.Nil(t, files)
 	}
 
 	// check loading files from empty valid directory
 	{
-		files, err := logman.LogfileList(tempdir)
+		files, err := manager.Files()
 		require.NoError(t, err)
 		require.Empty(t, files)
 	}
@@ -50,14 +69,14 @@ func TestLogfile(t *testing.T) {
 
 	// check loading files from valid directory with only dummy files
 	{
-		files, err := logman.LogfileList(tempdir)
+		files, err := manager.Files()
 		require.NoError(t, err)
 		require.Empty(t, files)
 	}
 
 	// create a first logger of kind-1
 	{
-		writer, err := logman.NewWriteCloser(tempdir, "kind-1")
+		writer, err := manager.New("kind-1")
 		require.NoError(t, err)
 		require.NotNil(t, writer)
 		_, err = writer.Write([]byte("blah\n"))
@@ -68,21 +87,21 @@ func TestLogfile(t *testing.T) {
 
 	// check loading files from the directory, should have one now
 	{
-		files, err := logman.LogfileList(tempdir)
+		files, err := manager.Files()
 		require.NoError(t, err)
 		require.Len(t, files, 1)
-		require.Equal(t, files[0].Dir, tempdir)
+		require.Equal(t, filepath.Dir(files[0].Path), tempdir)
 		require.NotEmpty(t, files[0].Name)
-		require.Equal(t, files[0].Path(), filepath.Join(tempdir, files[0].Name))
-		require.True(t, u.FileExists(files[0].Path()))
+		require.NotEmpty(t, files[0].Path)
+		require.True(t, u.FileExists(files[0].Path))
 		require.True(t, files[0].Latest)
-		require.Equal(t, files[0].Kind, "kind-1")
+		require.Equal(t, files[0].Name, "kind-1")
 	}
 
 	// create a second logger of kind-1
 	{
 		time.Sleep(time.Second)
-		writer, err := logman.NewWriteCloser(tempdir, "kind-1")
+		writer, err := manager.New("kind-1")
 		require.NoError(t, err)
 		require.NotNil(t, writer)
 		_, err = writer.Write([]byte("blah blah\n"))
@@ -93,27 +112,29 @@ func TestLogfile(t *testing.T) {
 
 	// check loading files from the directory, should have two now
 	{
-		files, err := logman.LogfileList(tempdir)
+		files, err := manager.Files()
 		require.NoError(t, err)
 		require.Len(t, files, 2)
 		for _, file := range files {
-			require.Equal(t, file.Dir, tempdir)
+			require.Equal(t, filepath.Dir(file.Path), tempdir)
 			require.NotEmpty(t, file.Name)
-			require.Equal(t, file.Path(), filepath.Join(tempdir, file.Name))
-			require.True(t, u.FileExists(file.Path()))
+			require.NotEmpty(t, file.Path)
+			require.True(t, u.FileExists(file.Path))
 		}
 	}
 
-	// try to gc with fewer files than the limit
-	{
-		err := logman.LogfileGC(tempdir, 10)
-		require.NoError(t, err)
-	}
+	/*
+		// try to gc with fewer files than the limit
+		{
+			err := manager.gc()
+			require.NoError(t, err)
+		}
+	*/
 
 	// create 10 new files
 	{
 		for i := 0; i < 10; i++ {
-			writer, err := logman.NewWriteCloser(tempdir, fmt.Sprintf("hello-%d", i))
+			writer, err := manager.New(fmt.Sprintf("hello-%d", i))
 			require.NoError(t, err)
 			err = writer.Close()
 			require.NoError(t, err)
@@ -122,53 +143,57 @@ func TestLogfile(t *testing.T) {
 
 	// check loading files from the directory, should have twelve now
 	{
-		files, err := logman.LogfileList(tempdir)
+		files, err := manager.Files()
 		require.NoError(t, err)
-		require.Len(t, files, 12)
+		require.Len(t, files, 10)
 		for _, file := range files {
-			require.Equal(t, file.Dir, tempdir)
+			require.Equal(t, filepath.Dir(file.Path), tempdir)
 			require.NotEmpty(t, file.Name)
-			require.Equal(t, file.Path(), filepath.Join(tempdir, file.Name))
-			require.True(t, u.FileExists(file.Path()))
+			require.NotEmpty(t, file.Path)
+			require.True(t, u.FileExists(file.Path))
 		}
 	}
 
-	// try to gc with fewer files than the limit
-	{
-		err := logman.LogfileGC(tempdir, 10)
-		require.NoError(t, err)
-	}
+	/*
+		// try to gc with fewer files than the limit
+		{
+			err := manager.gc()
+			require.NoError(t, err)
+		}
+	*/
 
 	// check loading files from the directory, should have ten now
 	{
-		files, err := logman.LogfileList(tempdir)
+		files, err := manager.Files()
 		require.NoError(t, err)
 		require.Len(t, files, 10)
 	}
 
-	// try to gc with the current amount of files
-	{
-		err := logman.LogfileGC(tempdir, 10)
-		require.NoError(t, err)
-	}
+	/*
+		// try to gc with the current amount of files
+		{
+			err := logman.LogfileGC(tempdir, 10)
+			require.NoError(t, err)
+		}
 
-	// check loading files from the directory, should still have ten
-	{
-		files, err := logman.LogfileList(tempdir)
-		require.NoError(t, err)
-		require.Len(t, files, 10)
-	}
+		// check loading files from the directory, should still have ten
+		{
+			files, err := manager.Files()
+			require.NoError(t, err)
+			require.Len(t, files, 10)
+		}
 
-	// try to gc with only one
-	{
-		err := logman.LogfileGC(tempdir, 1)
-		require.NoError(t, err)
-	}
+		// try to gc with only one
+		{
+			err := logman.LogfileGC(tempdir, 1)
+			require.NoError(t, err)
+		}
 
-	// check loading files from the directory, should now have only one
-	{
-		files, err := logman.LogfileList(tempdir)
-		require.NoError(t, err)
-		require.Len(t, files, 1)
-	}
+		// check loading files from the directory, should now have only one
+		{
+			files, err := manager.Files()
+			require.NoError(t, err)
+			require.Len(t, files, 1)
+		}
+	*/
 }