Forem: Inhere

gookit/goutil v0.7.2 Released: Enhanced Features & Fixes for an Improved Development Experience

Inhere — Thu, 20 Nov 2025 14:36:14 +0000

We're excited to announce the release of gookit/goutil v0.7.2! This version brings numerous new features, optimizations, and bug fixes, further enhancing the stability and usability of this Go utility library.
This update covers multiple modules, including math utilities, string processing, filesystem operations, and command-line flag handling, aiming to provide developers with a richer and more efficient toolkit.

Project Homepage: https://github.com/gookit/goutil
Full Changelog: v0.7.2 Release Notes
Full documentation: https://zread.ai/gookit/goutil

🛠️ Key Bug Fixes

This version fixes several key issues to ensure the stable operation of the library:

ccolor module: Fixed the issue where the NO_COLOR environment variable was not working correctly during printing, improving the compatibility of color output.
cflag module:
- Fixed a capp runtime error that occurred when parsing global flags.
- Fixed the issue where the OnAppFlagParsed event was not triggered when no command was input, ensuring the integrity of the event handling logic.

✨ New Feature Highlights

Math Utilities

Added the IsInteger function for strictly checking if a value is of an integer type (e.g., int(x), uint(x)).
Added StrictInt and StrictUint conversion functions for stricter integer type conversions.
Added the FormatBytes function to format byte sizes into human-readable strings (e.g., "1.2 MB"), convenient for log output and UI display.

String Utilities

Added the NumVersion function to quickly extract the numeric part from a version string.
Added the ReplaceVars function to support quick rendering of strings containing {var} placeholders, simplifying template replacement operations.
Added IsUpper and IsLower functions to check if a string is entirely uppercase or lowercase.
Added IsUint and IsPositiveNum functions to enhance string numeric validation capabilities.
Added BaseConvInt and BaseConvIntByTpl functions to support integer conversion between different bases.
Added the ContainsByteOne function to check if a string contains any of the specified bytes.
Optimized the MTimeBaseID function, which now supports bases greater than 36.

Filesystem Utilities

Added the EnsureDir function to ensure a directory exists (creates it if it doesn't).
Added HomeDir/UserHomeDir functions to get the user's home directory path.
Added CreateSymlink and IsSymlink functions to support the creation and detection of symbolic links.
Added FindAllInParentDirs, FindOneInParentDirs, and FindNameInParentDirs functions to support finding files in parent directories, simplifying the location of project configuration files.

Array/Slice Utilities

Added the ToMap function to convert a list (slice) to a map.
Added the Map1 function to convert a list to a new list (similar to a map operation).

Map Utilities

Added the AppendSMap function for merging string maps.
Added the AliasesNames function for handling alias names.

Testing Utilities

Added the assert.StrContainsAll assertion function to check if a string contains all specified substrings.
Added the testutil.SafeBuffer type, a thread-safe buffer designed for concurrent testing scenarios.
Enhanced testutil.EchoServer, which now supports responding with 404, 405, 500, or custom status codes, facilitating the testing of HTTP client error handling logic.

Command-line Utilities

The cflag module has a new HelpOnEmptyArgs configuration option to automatically display help information when no arguments are provided, improving user experience.
Optimized the rendering of help information.
Added support for setting aliases for cflag/capp commands.

Time Utilities

Added the FormatDuration function to format time duration into a clock-like format (e.g., "1h 23m 45s"), perfect for displaying performance statistics.

⚡ Performance Optimizations & Refactoring

Optimized the common logic of the ToStringWith function to improve conversion performance.
Refactored cflag.App into the subpackage capp.App, improving code organization.
Optimized the handling options logic in the ToInt64With function to enhance conversion efficiency.
Split integer conversion related code into conv2int.go and optimized the performance of all integer conversion related methods in mathutil.
Updated the VersionCompare function logic, fixing some comparison errors and improving the accuracy of version comparison.
The VarReplacer in textutil now supports parsing variable names as environment variables, enhancing dynamic configuration capabilities.

🌐 Platform Compatibility & Development Workflow

Added support for FreeBSD/Unix systems, expanding the platform coverage of the sysutil package.
Added comprehensive GitHub Copilot instructions for gookit/goutil, optimizing the AI-assisted development workflow.
Upgraded the github/codeql-action dependency from version 3 to 4, enhancing the security and capabilities of code analysis.

📝 Other Updates

Added a ShowLen option for dump output, allowing control over whether to display length information.
Updated the README generation CLI and related documentation, improving the project documentation generation process and templates.
Fixed unit test errors and unified the code style.
Updated some comments and code styles.

📦 How to Update

You can use the following command to get the latest version:

go get github.com/gookit/goutil@v0.7.2

Migration & Compatibility Notes

cflag -> cflag/capp Subpackage Refactoring: cflag.App has been refactored to capp.App. If your code directly references cflag.App, please adjust:
- Old: import "github.com/gookit/goutil/cflag"
- New: import "github.com/gookit/goutil/capp"
- And switch related types/calls to the App in the capp package.

TIP: This is a potential breaking change in this release, please check and update your references before upgrading.

VersionCompare and some string/version-related logic have been optimized. If you rely on the edge-case behavior of the old logic (such as equality comparison or sorting), please run relevant unit tests to verify after upgrading.

Example Snippets

Using `mathutil.IsInteger / StrictInt`

import "github.com/gookit/goutil/mathutil"
import "github.com/gookit/goutil/testutil/assert"

val := 123
if mathutil.IsInteger(val) {
    // true
}
i64, ok := mathutil.StrictInt("42") // Does not allow string to integer conversion
assert.False(t, ok)

Using `strutil.ReplaceVars`

import "github.com/gookit/goutil/strutil"

tpl := "Hello, {name}! Today is {day}."
out := strutil.ReplaceVars(tpl, map[string]string{
    "name": "Gopher",
    "day":  "Wednesday",
})
// Output: "Hello, Gopher! Today is Wednesday."

Using `fsutil.EnsureDir`

import "github.com/gookit/goutil/fsutil"

if err := fsutil.EnsureDir("/tmp/myapp/logs"); err != nil {
    // Handle error
}

🤝 Contributing

We thank all contributors for their efforts in this release! If you find any issues or have feature suggestions, please feel free to open an issue at GitHub Issues.

📖 More Information

Project Homepage: https://github.com/gookit/goutil
Full Changelog: v0.7.2 Release Notes
Full documentation: https://zread.ai/gookit/goutil

Enjoy the new features and improvements in v0.7.2

gookit/slog - release v0.5.8, Lightweight, configurable, extensible logging library

Inhere — Thu, 01 May 2025 02:01:37 +0000

We’re thrilled to announce the release of gookit/slog v0.5.8, a significant update to the lightweight, configurable, and extensible logging library for Go. With this release, we’ve addressed critical bug fixes, introduced powerful new features, and refined the overall functionality to offer an even more reliable logging experience for developers.

Github: https://github.com/gookit/slog

Highlights of v0.5.8

🛠️ Bug Fixes

Windows File Path Parsing Issue Resolved

Fixed a bug where log file paths could encounter parsing errors on Windows systems. (Commit)
Backup File Handling Improvement

Resolved a problem where setting BackupNum=0 caused all old files to be removed. (Commit)
File Rotation Stability

Fixed issues related to file rotation in short intervals, which previously caused conflicts and content overwrites. (Commit)
Old File Matching Issue

Resolved incorrect handling of file renaming (e.g., error.log to error.20250423_02.log). (Commit)

✨ New Features

Enhanced Logging Configuration

Improved the configuration functions, making it easier to fine-tune logging behavior. (Commit)
Top-Level Log Function

Introduced a Log function at the package's top level for more streamlined usage. (Commit)

🔄 Updates and Improvements

WithRotateTimeString Function Added

A new function to handle rotation time strings, along with corresponding tests. (Commit)
Refactored Clean Method

The clean method in the rotatefile handler now includes additional tests for compressing and cleaning files.(Commit)
Improved Debugging Logs

Added a debug mode environment variable and more detailed log outputs for development purposes. (Commit)
Optimized Rotate File Logic

Refactored the logic to ensure file extensions are always at the end and reduced lock ranges during write and rotation processes. (Commit)

📦 Dependency Updates

Updated github.com/gookit/goutil to v0.6.18. (PR #153)
Updated github.com/golang/glog from v1.1.1 to v1.2.4 for examples. (PR #157)

🧪 Improved Test Coverage

Added more unit test cases and internal test functions to ensure the stability and reliability of new features. (Commit)

Acknowledging New Contributors

We’re excited to welcome two new contributors to the gookit/slog community:

@ShyunnY for their work on the CallerFlagMode type alias. (PR #155)
@knbr13 for updating the code to use os.ReadFile instead of the deprecated ioutil.ReadFile. (PR #158)

Full Changelog

To explore all changes in detail, check out the v0.5.8 changelog.

This release represents a significant step forward in making gookit/slog a more robust, flexible, and user-friendly logging solution for Go developers. We’re grateful for the contributions from the community and look forward to seeing how these changes will enhance your projects.

Happy Logging!

gookit/goutil - released v0.6.10, an extension library of common Go features

Inhere — Wed, 05 Jul 2023 03:44:25 +0000

gookit/goutil An extended library of Go's common functionality. Contains: number, string, slice/array, Map, struct, reflection, text, file, error, time and date, test, CLI, command run, system information, formatting, common information acquisition, etc.

Github: https://github.com/gookit/goutil

v0.6.10 change log

Full changelog v0.6.9...v0.6.10

✨ New features

✨ feat: testutil - adds a new child package fakeobj to create fake objects for testing
✨ feat: testutil - adds a new function NewEchoServer() to start the echo server
✨ feat: byteutil - Buffer adds more useful methods for ease of use
✨ feat: dump - Special handling of custom int, uint type values, will print instructions in String format
✨ feat: fsutil - adds a new function to Glob() quickly list matching files
♻️ feat: httpreq - Refactoring the built-in HTTP client httpreq logic

👔 Update Adjustments

👔 up: structs - Update and support InitDefaults() for struct slice fields that are not null
👔 up: maputil - SimpleMerge() Supports deep merging of map[string]any data

Other adjustments

✅ test: Update some documentation and fix some unit tests
⬆️ dep: Update golang.org/x depends on the latest version

Some feature usage examples

dump - prints custom types

dump - special handles custom int, uint type values, and will print instructions in String format

Initialize the struct

Support for initializing the use of environment variables
Support initializing slice fields and nesting structs

type ExtraDefault struct {
    City   string `default:"some where"`
    Github string `default:"${ GITHUB_ADDR }"`
}

type User struct {
    Name  string        `default:"inhere"`
    Age   int           `default:"300"`
    Extra *ExtraDefault `default:""` // mark: need init
}

optFn := func(opt *structs.InitOptions) {
    opt.ParseEnv = true
}

obj := &User{}
err := structs.InitDefaults(obj, optFn)
goutil.PanicErr(err)

dump.P(obj)

Initialization result:

&structs_test.User {
  Name: string("inhere"), #len=6
  Age: int(300),
  Extra: &structs_test.ExtraDefault {
    City: string("some where"), #len=10
    Github: string("https://some .... url"), #len=21
  },
},

Test with Echo Server

Use testutil.NewEchoServer() to quickly create an HTTP echo server. Convenient for testing HTTP requests, responses, etc.

Usage examples:


var testSrvAddr string

func TestMain(m *testing.M) {
    s := testutil.NewEchoServer()
    defer s.Close()

    testSrvAddr = "http://" + s.Listener.Addr().String()
    fmt.Println("server addr:", testSrvAddr)

    m.Run()
}

func TestNewEchoServer(t *testing.T) {
    // can direct request the echo server
    r, err := http.Post(testSrvAddr, "text/plain", strings.NewReader("hello!"))
    assert.NoErr(t, err)

    // binding response to the testutil.EchoReply
    rr := testutil.ParseRespToReply(r)
    dump.P(rr)
    assert.Eq(t, "POST", rr.Method)
    assert.Eq(t, "text/plain", rr.ContentType())
    assert.Eq(t, "hello!", rr.Body)
}

v0.6.9 change log

Full changelog v0.6.8...v0.6.9

✨ New features

strutil - Added ToByteSize(),SafeByteSize() for converting size string (eg: 5MB) to byte size
strutil has added ParseSizeRange() to facilitate and quickly parse string size range expressions eg: 200kb~50mb
strutil - Added new utility functions: DatetimeNo(), RandWithTpl(), SimpleMatch()
byteutil - Add new utility functions: Random(), AppendAny()
fsutil - Add new utility functions: ReadOrErr(), ReadStringOrErr()
cliutil - Add new utility functions: Confirm(), ReadAsBool()
errorx - Add new utility functions Err(), Errf() for easy creation of error
structs - InitDefaults() enhanced to support nested structure pointer initialization
structs - SetValues() enhanced to support setting and processing structure pointer values
structs - Add ToSMap(), TryToSMap(), TryToSMap() to convert structure to string map
testutil/assert new assertion methods NotContainsKey(), NotContainsKeys()
Reflects new utility methods UnexportedValue(), SetUnexportedValue()
maputil new tool functions HasOneKey(), CombineToMap(), TryAnyMap()
Added utility functions AnyToSlice(), CombineToMap() in arrutil
jsonutil has added tool methods IsJSON(), IsJSONFast() to check whether it is JSON
♻️ fsutil/finder file and directory search reconstruction, enhanced functions, more convenient to use
timex new utility functions NowAddSec(), IsDuration(), InRange()
timex ToDuration() enhanced, support unit d, w and long unit hour, min, sec
mathutil new tool methods InRange(), OutRange(), InUintRange()
fsutil new tool method RemoveSub() to quickly delete subdirectories and files
maputil GetByPath() is enhanced to support matching paths similar to top.*.field to get values

👔 Update adjustments

strutil optimization ToByteSize() and GlobMatch() logic
struts - InitDefaults() supports initializing non-zero ptr substructure fields
💥 struts - InitDefaults() To initialize a substructure, the field must be marked with default:""

Other adjustments

📝 doc: README documentation updated, some subpackages added README
✅ test: Added and fixed some unit tests
⬆️ dep: update golang.org/x dependencies to latest version

Some feature usage examples

finder - find files or dir

fsutil/finder Provides a simple and fast way to find matching files and directories.

Built-in support Name, extension, suffix, prefix, glob, path, etc. include or exclude
Support matching file size, modification time (ModTime) and other extended matching methods

ff := finder.NewFinder("/path/to/dir/").
    // OnlyFindDir(). // default find files
    UseAbsPath().
    WithoutDotDir().
    WithDirName("testdata").
    Include(finder.HumanModTime("<10m")). // latest 10 minutes, to Now
    Include(finder.HumanSize("500kb~10mb")) // limit file size

// Find() returns chan, can be for handling
for el := range f.Find() {
    fmt.Println(el.Path())
}

strutil.ParseSizeRange

It is easy to parse the string size range to byte size.

opt := &strutil.ParseSizeOpt{}

mix, max, err := strutil.ParseSizeRange("1kb~1mb", opt)
goutil.PanicErr(err)
fmt.Println(min, max) // OUTPUT: 1024, 1048576

Examples of supported expression formats:

"1KB~2MB"       => 1KB to 2MB
"-1KB"          => <1KB
"~1MB"          => <1MB
"< 1KB"         => <1KB
"1KB"           => >1KB
"1KB~"          => >1KB
">1KB"          => >1KB
"+1KB"          => >1KB

timex.ParseRange()

timex.ParseRange() It is easy to quickly parse the relative time size range or keyword into time.Time

start, end, err := ParseRange("-1h~1h", nil)
goutil.PanicErr(err)


fmt.Println(start, end)

Examples of supported expression formats:

"-5h~-1h"           => 5 hours ago to 1 hour ago
"1h~5h"             => 1 hour after to 5 hours after
"-1h~1h"            => 1 hour ago to 1 hour after
"-1h"               => 1 hour ago to feature. eq "-1h~"
"-1h~0"             => 1 hour ago to now.
"< -1h" OR "~-1h"   => 1 hour ago.
"> 1h" OR "1h"      => 1 hour after to feature

// keyword: now, today, yesterday, tomorrow
"today"          => today start to today end
"yesterday"      => yesterday start to yesterday end
"tomorrow"       => tomorrow start to tomorrow end

More usage

For more instructions, see Unit tests for README and related methods

Github: https://github.com/gookit/goutil

gookit/slog - release v0.5.2, Lightweight, configurable, extensible logging library

Inhere — Tue, 20 Jun 2023 08:10:20 +0000

gookit/slog 📑 Lightweight, configurable, extensible logging library written in Go.
Support multi level, multi outputs and built-in multi file logger, buffers, clean, rotate-file handling.

Github https://github.com/gookit/slog

v0.5.2 changelog

Full changelog: https://github.com/gookit/slog/compare/v0.5.1...v0.5.2

Feature

✨ feat: Add new option FilePerm to customize the permission on log file creation. issues #102 https://github.com/gookit/slog/commit/699ecd8bc2dea0fb35607ba89d4299e86f96e40b
✨ feat: rotatefile - Added new option ModeCreate to support creating log files at rotation time. https://github.com/gookit/slog/commit/8c4a9a08a9b3432a699f6770b73935ecfd42e5b8

Update

👔 up: Update and add more unit tests, upgrade goutil to v0.6.10 https://github.com/gookit/slog/commit/693cc04eb0e375183357be18893cbecaa171ffa1
📝 doc: Update README document description https://github.com/gookit/slog/commit/cbf77c38db5615a9a7ec8ab07853b2f9e3517bfa
✅ test: Add more unit test cases https://github.com/gookit/slog/commit/8468ea470645bb981fb34002176671bac1a9559e

New feature usage

Custom log file permissions

The log file permission flag created by configuring the FilePerm setting of hander.Config.

h1 := handler.MustFileHandler("/tmp/error.log",
    handler.WithLogLevels(slog.DangerLevels),
    handler.WithFilePerm(0644), // <- sets log file permissions
)

slog.PushHandler(h1)

Split files using ModeCreate mode

about RotateMode:

ModeRename By default, every time rename handles rotation.
ModeCreate Create files only by split time

Setting RotateMode=ModeCreate allows log files to be created only by split time.

h1 := handler.MustRotateFile(
    "/tmp/error.log",
    rotatefile.EveryHour, // split by hour
    handler.WithLogLevels(slog.DangerLevels),
    handler.WithRotateMode(rotatefile.ModeCreate), // set RotateMode=ModeCreate
)

slog.PushHandler(h1)

Configure the logfile as /tmp/error.log in the above example. When set to ModeCreate mode, the file will not actually be created,
Instead, it will be created according to the actual split time:

/tmp/error.log.20230618_1500
/tmp/error.log.20230618_1600
/tmp/error.log.20230618_1700
...

Tips: The ModeCreate mode can be applied to command-line tool applications. Because they exit after each execution, ModeRename may not be able to split files on time.

And using ModeRename mode will have the following effect:

/tmp/error.log # <- Logs are always written to this file
/tmp/error.log.20230618_1500
/tmp/error.log.20230618_1600
/tmp/error.log.20230618_1700
...

More usage

GO tool library goutil released v0.6.4

Inhere — Sun, 12 Feb 2023 03:52:39 +0000

gookit/goutil - 💪 Helper Utils For Go: int, byte, string, array/slice, map, struct, dump, convert/format, error, web/http, cli/flag, OS/ENV, filesystem, system, test/assert, time and more.

GitHub: https://github.com/gookit/goutil

Changlog from v0.6.2 to v0.6.4

Fixed

🐛 fix(env, str): fix the envutil test error and update some str util 2e7aa63
🐛 fix(dump): makeslice: cap out of range. fix: #76 4ba9b10

Feature

👔 feat: str - add some check util func 0e4792a
👔 feat: str/textutil - support quick replace vars for give text ecc23cb
👔 feat: sys,proc - add and update some util func aa78114
✨ feat: fs - add more new fs util functions 3352512
✨ feat: map, struct - add new util functions 90af09e
✨ feat: stdio - add new util functions ea243d6
✨ feat: arr - add new util functions for in/notIn check 2a18ca2
✨ feat: testutil - add new util func IsMatchAll() d0dade8
✨ feat: math - add new util func for compare value 176923b
feat: error, test - add some new helper util fuctions 7188216
✨ feat: fs - add more make dir util func c4447cb
✨ feat: env,sys - add new func for get all env info map b3d7669
✨ feat: str - add new func for check ignore case string 746eb35
✨ feat: goutil - add new func for quick run go func 97a2863
✨ feat: arr - add new func for quick convert slice type 75d8d89
✨ feat: reflects - add new func for convert slice value and more util f87fc86
✨ feat: structs - func InitDefaults() support set slice field 948fa70
✨ feat: byte - add StrOrErr(), SafeString() for convert to string 767ed80
✨ feat: cmdr - add new option for output result to OS 6aaea78

Update

👔 up: str, math - add new util func OrElse() cb21fbc
👔 up: str - update some util func and add more tests a3e07f4
🐛 up: textscan - fix multi inline comments parse error bf68c94
👔 up: str,math - update some util func eaf0990
👔 up: str,byte - add and update some util func cf5d34e
👔 up: byte,cflag - update and add some new tests 6e47f69
👔 up(env, str): update the env var parse and strutil.Valid() 5193849
👔 up(str): update some str value get func 676fe4e
✨ up(env,sys): update some func and add new util func 9eaddb5
👔 up(str): update the SplitInlineComment() logic 31445cd
👔 up(sys): update the SearchPath(), support limit result 67cbae1
✅ up(sys,env,map): add more tests case for util func 392536c
👔 up(fs,sys): update some fs and sys util func run logic 7727628
👔 up(struct): update some structs comments and update readme f461852
👔 up(str): update some string util comments and func 796d1fe

Other

build(deps): bump golang.org/x/text from 0.5.0 to 0.6.0 79d7781
doc: re-generate the README docs 42e3084
doc: update the doc parse logic, support generic types 030676d
doc: generate and update README docs f342e92
build(deps): bump golang.org/x/text from 0.6.0 to 0.7.0 1e3ea77

GitHub: https://github.com/gookit/goutil

Lightweight event management, dispatch tool library implemented by Go

Inhere — Thu, 07 Jul 2022 14:37:14 +0000

event - Lightweight event management, dispatch tool library implemented by Go

Support for custom definition event objects
Support for adding multiple listeners to an event
Supports setting the priority of the event listener. The higher the priority, the higher the trigger.
Support for a set of event listeners based on the event name prefix PREFIX.*.
- add app.* event listen, trigger app.run app.end, Both will trigger the app.* event at the same time
Support for using the wildcard * to listen for triggers for all events
Complete unit testing, unit coverage > 95%

Repo and doc

Github: https://github.com/gookit/event
Godoc for github

Install

go install github.com/gookit/event

Quick start

package main

import (
    "fmt"

    "github.com/gookit/event"
)

func main() {
    // Register event listener
    event.On("evt1", event.ListenerFunc(func(e event.Event) error {
        fmt.Printf("handle event: %s\n", e.Name())
        return nil
    }), event.Normal)

    // Register multiple listeners
    event.On("evt1", event.ListenerFunc(func(e event.Event) error {
        fmt.Printf("handle event: %s\n", e.Name())
        return nil
    }), event.High)

    // ... ...

    // Trigger event
    // Note: The second listener has a higher priority, so it will be executed first.
    event.MustFire("evt1", event.M{"arg0": "val0", "arg1": "val1"})
}

Note: The second listener has a higher priority, so it will be executed first.

Using the wildcard

func main() {
    dbListener1 := event.ListenerFunc(func(e event.Event) error {
        fmt.Printf("handle event: %s\n", e.Name())
        return nil
    })

    event.On("app.db.*", dbListener1, event.Normal)
}

Trigger events on other logic:

func doCreate() {
    // do something ...
    // Trigger event
    event.MustFire("app.db.create", event.M{"arg0": "val0", "arg1": "val1"})
}

func doUpdate() {
    // do something ...
    // Trigger event
    event.MustFire("app.db.update", event.M{"arg0": "val0"})
}

Like the above, triggering the app.db.create app.db.update event
will trigger the execution of the dbListener1 listener.

Write event listeners

Using anonymous functions

You can use anonymous function for quick write an event lister.

package mypgk

import (
    "fmt"

    "github.com/gookit/event"
)

var fnHandler = func(e event.Event) error {
    fmt.Printf("handle event: %s\n", e.Name())
    return nil
}

func Run() {
    // register
    event.On("evt1", event.ListenerFunc(fnHandler), event.High)
}

Using the structure method

You can use struct write an event lister, and it should implementation interface event.Listener.

interface:

// Listener interface
type Listener interface {
    Handle(e Event) error
}

example:

Implementation interface event.Listener

package mypgk

import "github.com/gookit/event"

type MyListener struct {
    // userData string
}

func (l *MyListener) Handle(e event.Event) error {
    e.Set("result", "OK")
    return nil
}

Register multiple event listeners

Can implementation interface event.Subscriber for register
multiple event listeners at once.

interface:

// Subscriber event subscriber interface.
// you can register multi event listeners in a struct func.
type Subscriber interface {
    // SubscribedEvents register event listeners
    // key: is event name
    // value: can be Listener or ListenerItem interface
    SubscribedEvents() map[string]interface{}
}

example

Implementation interface event.Subscriber

package mypgk

import (
    "fmt"

    "github.com/gookit/event"
)

type MySubscriber struct {
    // ooo
}

func (s *MySubscriber) SubscribedEvents() map[string]interface{} {
    return map[string]interface{}{
        "e1": event.ListenerFunc(s.e1Handler),
        "e2": event.ListenerItem{
            Priority: event.AboveNormal,
            Listener: event.ListenerFunc(func(e Event) error {
                return fmt.Errorf("an error")
            }),
        },
        "e3": &MyListener{},
    }
}

func (s *MySubscriber) e1Handler(e event.Event) error {
    e.Set("e1-key", "val1")
    return nil
}

Write custom events

If you want to customize the event object or define some fixed event information in advance,
you can implement the event.Event interface.

interface:

// Event interface
type Event interface {
    Name() string
    // Target() interface{}
    Get(key string) interface{}
    Add(key string, val interface{})
    Set(key string, val interface{})
    Data() map[string]interface{}
    SetData(M) Event
    Abort(bool)
    IsAborted() bool
}

examples:

package mypgk

import "github.com/gookit/event"

type MyEvent struct {
    event.BasicEvent
    customData string
}

func (e *MyEvent) CustomData() string {
    return e.customData
}

Usage:

e := &MyEvent{customData: "hello"}
e.SetName("e1")
event.AddEvent(e)

// add listener
event.On("e1", event.ListenerFunc(func(e event.Event) error {
    fmt.Printf("custom Data: %s\n", e.(*MyEvent).CustomData())
    return nil
}))

// trigger
event.Fire("e1", nil)
// OR
// event.FireEvent(e)

Main method

On/Listen(name string, listener Listener, priority ...int) Register event listener
Subscribe/AddSubscriber(sbr Subscriber) Subscribe to support registration of multiple event listeners
Trigger/Fire(name string, params M) (error, Event) Trigger event by name and params
MustTrigger/MustFire(name string, params M) Event Trigger event, there will be panic if there is an error
FireEvent(e Event) (err error) Trigger an event based on a given event instance
FireBatch(es ...interface{}) (ers []error) Trigger multiple events at once
AsyncFire(e Event) Async fire event by 'go' keywords

slog - Lightweight, configurable, extensible Go logging library

Inhere — Thu, 16 Jun 2022 02:33:47 +0000

slog is a lightweight, configurable, extensible Go logging library.

Features

Simple, directly available without configuration
Support common log level processing.
- eg: trace debug info notice warn error fatal panic
Support any extension of Handler Formatter as needed
Supports adding multiple Handler log processing at the same time, outputting logs to different places
Support to custom log message Formatter
- Built-in json text two log record formatting Formatter
Support to custom build log messages Handler
- The built-in handler.Config handler.Builder can easily and quickly build the desired log handler
Has built-in common log write handler program
- console output logs to the console, supports color output
- writer output logs to the specified io.Writer
- file output log to the specified file, optionally enable buffer to buffer writes
- simple output log to the specified file, write directly to the file without buffering
- rotate_file outputs logs to the specified file, and supports splitting files by time and size, and buffer buffered writing is enabled by default
- See ./handler folder for more built-in implementations

Output logs to file

Support enabling buffer for log writing
Support splitting log files by time and size
Support configuration to compress log files via gzip
Support clean old log files by BackupNum BackupTime

Git repository

Github: https://github.com/gookit/slog

Install

go get github.com/gookit/slog

Quick start

package main

import (
    "github.com/gookit/slog"
)

func main() {
    slog.Trace("this is a log message")
    slog.Debug("this is a log message")
    slog.Info("this is a log message")
    slog.Notice("this is a log message")
    slog.Warn("this is a log message")
    slog.Error("this is a log message")
    slog.Fatal("this is a log message")
}

output preview:

Logs to file

Using slog to output logs to files is very convenient, and supports multiple files, splitting by time, etc.

package main

import (
    "github.com/gookit/slog"
    "github.com/gookit/slog/handler"
    "github.com/gookit/slog/rotatefile"
)

func main() {
    defer slog.MustFlush()

    // DangerLevels contains: slog.PanicLevel, slog.ErrorLevel, slog.WarnLevel
    h1 := handler.MustRotateFile("/tmp/logs/app_error.log", rotatefile.EveryHour, 
        handler.WithLogLevels(slog.DangerLevels),
    )

    // NormalLevels contains: slog.InfoLevel, slog.NoticeLevel, slog.DebugLevel, slog.TraceLevel
    h2 := handler.MustRotateFile("/tmp/logs/app_info.log", rotatefile.EveryHour,
        handler.WithLogLevels(slog.NormalLevels),
    )

    slog.PushHandler(h1)
    slog.PushHandler(h2)

    // add logs
    slog.Info("info message text")
    slog.Error("error message text")
}

See logs dir:

$ ls /tmp/logs
app_error.log
app_info.log

More usage

More usage please see README

gookit/goutil - Useful utils package for the Go

Inhere — Mon, 13 Jun 2022 07:40:15 +0000

gookit/goutil 💪 Useful utils package for the Go: int, string, array/slice, map, error, time, format, CLI, ENV, filesystem, system, testing and more.

Sub-packages

arrutil: Array/Slice util functions. eg: check, convert, formatting
dump: Simple variable printing tool, printing slice, map will automatically wrap each element and display the call location
cliutil Command-line util functions. eg: read input, exec command, cmdline parse/build
errorx Provide an enhanced error implements for go, allow with stacktraces and wrap another error.
envutil ENV util for current runtime env information. eg: get one, get info, parse var
fmtutil Format data util functions. eg: data, size
fsutil Filesystem util functions, quick create, read and write file. eg: file and dir check, operate
jsonutil some util functions for quick read, write, encode, decode JSON data.
maputil Map data util functions. eg: convert, sub-value get, simple merge
mathutilMath(int, number) util functions. eg: convert, math calc, random
netutil Network util functions
- netutil/httpreq An easier-to-use HTTP client that wraps http.Client
strutil String util functions. eg: bytes, check, convert, encode, format and more
sysutil System util functions. eg: sysenv, exec, user, process
testutil Test help util functions. eg: http test, mock ENV value
timex Provides an enhanced time.Time implementation. Add more commonly used functional methods
- such as: DayStart(), DayAfter(), DayAgo(), DateFormat() and more.

Git repository

Github: https://github.com/gookit/goutil
Gitee: https://gitee.com/gookit/goutil

Install

go get github.com/gookit/goutil

Usage

goutil/dump

goutil/dump is a golang data printing toolkit that prints beautiful and easy to read go slice, map, struct data.

Examples

//  go run ./dump/_examples/struct.go
func main() {
    s1 := &struct {
        cannotExport map[string]interface{}
    }{
        cannotExport: map[string]interface{}{
            "key1": 12,
            "key2": "abcd123",
        },
    }

    s2 := struct {
        ab string
        Cd int
    }{
        "ab", 23,
    }

    color.Infoln("- Use fmt.Println:")
    fmt.Println(s1, s2)

    color.Infoln("\n- Use dump.Println:")
    dump.P(s1,s2)
}

Output:

goutil/timex

goutil/timex Provides an enhanced time.Time implementation, and add more commonly used functional methods.

such as: DayStart(), DayAfter(), DayAgo(), DateFormat() and more

Create timex instance:

now := timex.Now()

// from time.Time
tx := timex.New(time.Now())
tx := timex.FromTime(time.Now())

// from time unix
tx := timex.FromUnix(1647411580)

Create time for date string:

// auto match layout by datetime
tx, err  := timex.FromString("2022-04-20 19:40:34")
// custom set the datetime layout
tx, err  := timex.FromString("2022-04-20 19:40:34", "2006-01-02 15:04:05")
// use date template as layout
tx, err  := timex.FromDate("2022-04-20 19:40:34", "Y-m-d H:I:S")

Quickly fetch time:

tx := timex.Now()

tx.Yesterday()
tx.Tomorrow()

tx.DayStart() // get time at Y-m-d 00:00:00
tx.DayEnd() // get time at Y-m-d 23:59:59
tx.HourStart() // get time at Y-m-d H:00:00
tx.HourEnd() // get time at Y-m-d H:59:59

tx.AddDay(2)
tx.AddHour(1)
tx.AddMinutes(15)
tx.AddSeconds(120)

Quickly format date：

tx.DateFormat("y/m/d H:I")
date := tx.DateFormat("Y-m-d H:I:S") // Output: 2022-04-20 19:40:34
date = tx.DateFormat("y-m-d H:I:S") // Output: 22-04-20 19:40:34

More usage

More utils and usage please see README https://github.com/gookit/goutil/blob/master/README.md

goutil/dump - print beautiful and easy-to-read go data

Inhere — Thu, 24 Feb 2022 05:03:29 +0000

goutil/dump - is a golang data printing toolkit that can print beautiful and easy-to-read go slice, map, and struct data.

main functions:

Simple to use, just call dump.P(vars…) directly
Supports all basic data types.
Supports slice, map, and struct data structures.
Supports passing in and printing multiple variables
Default output call location, easy to use
Supports custom features, such as indentation and color themes.

Preview：

Git Repo:

Github: https://github.com/gookit/goutil/
GoDoc: https://pkg.go.dev/github.com/gookit/goutil/dump

Print basic type



package main
import "github.com/gookit/goutil/dump"

// rum demo:
//     go run ./dump/_examples/basic_types.go
func main() {
    dump.P(
        nil, true,
        12, int8(12), int16(12), int32(12), int64(12),
        uint(22), uint8(22), uint16(22), uint32(22), uint64(22),
        float32(23.78), float64(56.45),
        'c', byte('d'),
        "string",
    )
}

Output：

Print slice

Printing array, slice will output one element per line, and will output the length at the end.



package main

import "github.com/gookit/goutil/dump"

// rum demo:
//     go run ./dump/_examples/slice.go
func main() {
    dump.P(
        []byte("abc"),
        []int{1, 2, 3},
        []string{"ab", "cd"},
        []interface{}{
            "ab",
            234,
            []int{1, 3},
            []string{"ab", "cd"},
        },
    )
}

Output：

Print map

When printing the map data structure, one element per line is output, and the length of the map is output at the end.



package main

import "github.com/gookit/goutil/dump"

// rum demo:
//     go run ./map.go
//     go run ./dump/_examples/map.go
func main() {
    dump.P(
        map[string]interface{}{
            "key0": 123,
            "key1": "value1",
            "key2": []int{1, 2, 3},
            "key3": map[string]string{
                "k0": "v0",
                "k1": "v1",
            },
        },
    )
}

Output：

Print struct

Print struct data, the pointer type will automatically print the underlying real data.



package main

import (
    "fmt"
    "github.com/gookit/color"
    "github.com/gookit/goutil/dump"
)

// rum demo:
//     go run ./struct.go
//     go run ./dump/_examples/struct.go
func main() {
    s1 := &struct {
        cannotExport map[string]interface{}
    }{
        cannotExport: map[string]interface{}{
            "key1": 12,
            "key2": "abcd123",
        },
    }    s2 := struct {
        ab string
        Cd int
    }{
        "ab", 23,
    }
    color.Infoln("- Use fmt.Println:")
    fmt.Println(s1, s2)
    color.Infoln("\n- Use dump.Println:")
    dump.P(
        s1,
        s2,
    )
}

Output：

Custom dumper

you can customize dumper options. Such as indentation and color theme



// Options for dump vars

type Options struct {

    // Output the output writer

    Output io.Writer

    // NoType dont show data type TODO

    NoType bool

    // NoColor don't with color

    NoColor bool

    // IndentLen width. default is 2

    IndentLen int

    // IndentChar default is one space

    IndentChar byte

    // MaxDepth for nested print

    MaxDepth int

    // ShowFlag for display caller position

    ShowFlag int

    // MoreLenNL array/slice elements length > MoreLenNL, will wrap new line

    // MoreLenNL int

    // CallerSkip skip for call runtime.Caller()

    CallerSkip int

    // ColorTheme for print result.

    ColorTheme Theme

}

Git & docs

Github: https://github.com/gookit/goutil/
GoDoc: https://pkg.go.dev/github.com/gookit/goutil/dump

Forem: Inhere

gookit/goutil v0.7.2 Released: Enhanced Features & Fixes for an Improved Development Experience

🛠️ Key Bug Fixes

✨ New Feature Highlights

Math Utilities

String Utilities

Filesystem Utilities

Array/Slice Utilities

Map Utilities

Testing Utilities

Command-line Utilities

Time Utilities

⚡ Performance Optimizations & Refactoring

🌐 Platform Compatibility & Development Workflow

📝 Other Updates

📦 How to Update

Migration & Compatibility Notes

Example Snippets

Using mathutil.IsInteger / StrictInt

Using strutil.ReplaceVars

Using fsutil.EnsureDir

🤝 Contributing

📖 More Information

gookit/slog - release v0.5.8, Lightweight, configurable, extensible logging library

Highlights of v0.5.8

🛠️ Bug Fixes

✨ New Features

🔄 Updates and Improvements

📦 Dependency Updates

🧪 Improved Test Coverage

Acknowledging New Contributors

Full Changelog

gookit/goutil - released v0.6.10, an extension library of common Go features

v0.6.10 change log

✨ New features

👔 Update Adjustments

Other adjustments

Some feature usage examples

dump - prints custom types

Initialize the struct

Test with Echo Server

v0.6.9 change log

✨ New features

👔 Update adjustments

Other adjustments

Some feature usage examples

finder - find files or dir

strutil.ParseSizeRange

timex.ParseRange()

More usage

gookit/slog - release v0.5.2, Lightweight, configurable, extensible logging library

v0.5.2 changelog

Feature

Update

New feature usage

Custom log file permissions

Split files using ModeCreate mode

More usage

GO tool library goutil released v0.6.4

Changlog from v0.6.2 to v0.6.4

Fixed

Feature

Update

Other

Lightweight event management, dispatch tool library implemented by Go

Repo and doc

Install

Quick start

Using the wildcard

Write event listeners

Using anonymous functions

Using the structure method

Register multiple event listeners

Write custom events

Main method

slog - Lightweight, configurable, extensible Go logging library

Features

Output logs to file

Git repository

Install

Using `mathutil.IsInteger / StrictInt`

Using `strutil.ReplaceVars`

Using `fsutil.EnsureDir`