feat: expose startup message customization hooks

app.go

@@ -1325,16 +1325,14 @@ func (app *App) serverErrorHandler(fctx *fasthttp.RequestCtx, err error) {
 }
 
 // startupProcess Is the method which executes all the necessary processes just before the start of the server.
-func (app *App) startupProcess() *App {
+func (app *App) startupProcess() {
 	app.mutex.Lock()
 	defer app.mutex.Unlock()
 
 	app.mountStartupProcess()
 
 	// build route tree stack
 	app.buildTree()
-
-	return app
 }
 
 // Run onListen hooks. If they return an error, panic.

docs/api/hooks.md

@@ -168,6 +168,64 @@ func main() {
 </TabItem>
 </Tabs>
 
+### ListenData
+
+`ListenData` exposes runtime metadata about the listener:
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `Host` | `string` | Resolved hostname or IP address. |
+| `Port` | `string` | The bound port. |
+| `TLS` | `bool` | Indicates whether TLS is enabled. |
+| `Version` | `string` | Fiber version reported in the startup banner. |
+| `AppName` | `string` | Application name from the configuration. |
+| `HandlerCount` | `int` | Total registered handler count. |
+| `ProcessCount` | `int` | Number of processes Fiber will use. |
+| `PID` | `int` | Current process identifier. |
+| `Prefork` | `bool` | Whether prefork is enabled. |
+| `ChildPIDs` | `[]int` | Child process identifiers when preforking. |
+| `ColorScheme` | [`Colors`](https://github.com/gofiber/fiber/blob/main/color.go) | Active color scheme for the startup message. |
+
+### Startup message customization
+
+Use `OnPreStartupMessage` to tweak the banner before Fiber prints it, and `OnPostStartupMessage` to run logic after the banner is printed (or skipped):
+
+- Assign `sm.Header` to override the ASCII art banner. Leave it empty to use the default.
+- Provide `sm.PrimaryInfo` and/or `sm.SecondaryInfo` maps to replace the primary (server URL, handler counts, etc.) and secondary (prefork status, PID, process count) sections.
+- Set `sm.PreventDefault = true` to suppress the built-in banner without affecting other hooks.
+- `PostStartupMessageData` reports whether the banner was skipped via the `Disabled`, `IsChild`, and `Prevented` flags.
+
+```go title="Customize the startup message"
+package main
+
+import (
+    "fmt"
+    "os"
+
+    "github.com/gofiber/fiber/v3"
+)
+
+func main() {
+    app := fiber.New()
+
+    app.Hooks().OnPreStartupMessage(func(sm *fiber.PreStartupMessageData) error {
+        sm.Header = "FOOBER " + sm.Version + "\n-------"
+        sm.PrimaryInfo = fiber.Map{"Git hash": os.Getenv("GIT_HASH")}
+        sm.SecondaryInfo = fiber.Map{"Prefork": sm.Prefork}
+        return nil
+    })
+
+    app.Hooks().OnPostStartupMessage(func(sm fiber.PostStartupMessageData) error {
+        if !sm.Disabled && !sm.IsChild && !sm.Prevented {
+            fmt.Println("startup completed")
+        }
+        return nil
+    })
+
+    app.Listen(":5000")
+}
+```
+
 ## OnFork
 
 Runs in the child process after a fork.

docs/whats_new.md

@@ -295,6 +295,29 @@ app.Listen("app.sock", fiber.ListenerConfig{
 })
 ```
 
+- Expanded `ListenData` with versioning, handler, process, and PID metadata, plus dedicated startup message hooks for customization.
+
+```go
+app := fiber.New()
+
+app.Hooks().OnPreStartupMessage(func(sm *fiber.PreStartupMessageData) error {
+    sm.Header = "FOOBER " + sm.Version + "\n-------"
+    sm.PrimaryInfo = fiber.Map{"Git hash": os.Getenv("GIT_HASH")}
+    sm.SecondaryInfo = fiber.Map{"Process count": sm.ProcessCount}
+    // Set sm.PreventDefault = true to suppress the default banner entirely.
+    return nil
+})
+
+app.Hooks().OnPostStartupMessage(func(sm fiber.PostStartupMessageData) error {
+    if !sm.Disabled && !sm.IsChild && !sm.Prevented {
+        log.Println("startup completed")
+    }
+    return nil
+})
+
+go app.Listen(":3000")
+```
+
 ## 🗺 Router
 
 We have slightly adapted our router interface

hooks.go

@@ -1,6 +1,9 @@
 package fiber
 
 import (
+	"fmt"
+	"sort"
+
 	"github.com/gofiber/fiber/v3/log"
 )
 
@@ -15,6 +18,10 @@
 	OnGroupNameHandler = OnGroupHandler
 	// OnListenHandler runs when the application begins listening and receives the listener details.
 	OnListenHandler = func(ListenData) error
+	// OnPreStartupMessageHandler runs before Fiber prints the startup banner.
+	OnPreStartupMessageHandler = func(*PreStartupMessageData) error
+	// OnPostStartupMessageHandler runs after Fiber prints (or skips) the startup banner.
+	OnPostStartupMessageHandler = func(PostStartupMessageData) error
 	// OnPreShutdownHandler runs before the application shuts down.
 	OnPreShutdownHandler = func() error
 	// OnPostShutdownHandler runs after shutdown and receives the shutdown result.
@@ -36,17 +43,183 @@
 	onGroup        []OnGroupHandler
 	onGroupName    []OnGroupNameHandler
 	onListen       []OnListenHandler
+	onPreStartup   []OnPreStartupMessageHandler
+	onPostStartup  []OnPostStartupMessageHandler
 	onPreShutdown  []OnPreShutdownHandler
 	onPostShutdown []OnPostShutdownHandler
 	onFork         []OnForkHandler
 	onMount        []OnMountHandler
 }
 
-// ListenData is a struct to use it with OnListenHandler
+type StartupMessageLevel int
+
+const (
+	// StartupMessageLevelInfo represents informational startup message entries.
+	StartupMessageLevelInfo StartupMessageLevel = iota
+	// StartupMessageLevelWarning represents warning startup message entries.
+	StartupMessageLevelWarning
+	// StartupMessageLevelError represents error startup message entries.
+	StartupMessageLevelError
+)
+
+// startupMessageEntry represents a single line of startup message information.
+type startupMessageEntry struct {
+	key      string
+	title    string
+	value    string
+	priority int
+	level    StartupMessageLevel
+}
+
+// ListenData contains the listener metadata provided to OnListenHandler.
 type ListenData struct {
-	Host string
-	Port string
-	TLS  bool
+	ColorScheme Colors
+	Host        string
+	Port        string
+	Version     string
+	AppName     string
+
+	ChildPIDs []int
+
+	HandlerCount int
+	ProcessCount int
+	PID          int
+
+	TLS     bool
+	Prefork bool
+}
+
+// PreStartupMessageData contains metadata exposed to OnPreStartupMessage hooks.
+type PreStartupMessageData struct {
+	*ListenData
+
+	entries []startupMessageEntry
+
+	Header string
+
+	PreventDefault bool
+}
+
+func (sm *PreStartupMessageData) AddInfo(key, title, value string, priority ...int) {
+	pri := -1
+	if len(priority) > 0 {
+		pri = priority[0]
+	}
+
+	sm.addEntry(key, title, value, pri, StartupMessageLevelInfo)
+}
+
+func (sm *PreStartupMessageData) AddWarning(key, title, value string, priority ...int) {
+	pri := -1
+	if len(priority) > 0 {
+		pri = priority[0]
+	}
+
+	sm.addEntry(key, title, value, pri, StartupMessageLevelWarning)
+}
+
+func (sm *PreStartupMessageData) AddError(key, title, value string, priority ...int) {
+	pri := -1
+	if len(priority) > 0 {
+		pri = priority[0]
+	}
+
+	sm.addEntry(key, title, value, pri, StartupMessageLevelError)
+}
+
+func (sm *PreStartupMessageData) EntryKeys() []string {
+	keys := make([]string, 0, len(sm.entries))
+	for _, entry := range sm.entries {
+		keys = append(keys, entry.key)
+	}
+	return keys
+}
+
+func (sm *PreStartupMessageData) ResetEntries() {
+	sm.entries = sm.entries[:0]
+}
+
+func (sm *PreStartupMessageData) addEntry(key, title, value string, priority int, level StartupMessageLevel) {
+	if sm.entries == nil {
+		sm.entries = make([]startupMessageEntry, 0)
+	}
+
+	for i, entry := range sm.entries {
+		if entry.key == key {
+			sm.entries[i].value = value
+			sm.entries[i].title = title
+			sm.entries[i].level = level
+			sm.entries[i].priority = priority
+			return
+		}
+	}
+
+	sm.entries = append(sm.entries, startupMessageEntry{key: key, title: title, value: value, level: level, priority: priority})
+}
+
+func (sm *PreStartupMessageData) DeleteEntry(key string) {
+	if sm.entries == nil {
+		return
+	}
+
+	for i, entry := range sm.entries {
+		if entry.key == key {
+			sm.entries = append(sm.entries[:i], sm.entries[i+1:]...)
+			return
+		}
+	}
+}
+
+func newPreStartupMessageData(listenData ListenData) *PreStartupMessageData {
+	clone := listenData
+	if len(listenData.ChildPIDs) > 0 {
+		clone.ChildPIDs = append([]int(nil), listenData.ChildPIDs...)
+	}
+
+	return &PreStartupMessageData{ListenData: &clone}
+}
+
+// PostStartupMessageData contains metadata exposed to OnPostStartupMessage hooks.
+type PostStartupMessageData struct {
+	*ListenData
+
+	Disabled  bool
+	IsChild   bool
+	Prevented bool
+}
+
+func newPostStartupMessageData(listenData ListenData, disabled, isChild, prevented bool) PostStartupMessageData {
+	clone := listenData
+	if len(listenData.ChildPIDs) > 0 {
+		clone.ChildPIDs = append([]int(nil), listenData.ChildPIDs...)
+	}
+
+	return PostStartupMessageData{
+		ListenData: &clone,
+		Disabled:   disabled,
+		IsChild:    isChild,
+		Prevented:  prevented,
+	}
+}
+
+func mapToEntries(values Map) ([]startupMessageEntry, bool) {
+	if len(values) == 0 {
+		return nil, false
+	}
+
+	keys := make([]string, 0, len(values))
+	for key := range values {
+		keys = append(keys, key)
+	}
+
+	sort.Strings(keys)
+
+	entries := make([]startupMessageEntry, 0, len(values))
+	for _, key := range keys {
+		entries = append(entries, startupMessageEntry{key: key, value: fmt.Sprint(values[key])})
+	}
+
+	return entries, true
 }
 
 func newHooks(app *App) *Hooks {
@@ -57,6 +230,8 @@
 		onGroupName:    make([]OnGroupNameHandler, 0),
 		onName:         make([]OnNameHandler, 0),
 		onListen:       make([]OnListenHandler, 0),
+		onPreStartup:   make([]OnPreStartupMessageHandler, 0),
+		onPostStartup:  make([]OnPostStartupMessageHandler, 0),
 		onPreShutdown:  make([]OnPreShutdownHandler, 0),
 		onPostShutdown: make([]OnPostShutdownHandler, 0),
 		onFork:         make([]OnForkHandler, 0),
@@ -107,6 +282,20 @@
 	h.app.mutex.Unlock()
 }
 
+// OnPreStartupMessage is a hook to execute user functions before the startup message is printed.
+func (h *Hooks) OnPreStartupMessage(handler ...OnPreStartupMessageHandler) {
+	h.app.mutex.Lock()
+	h.onPreStartup = append(h.onPreStartup, handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnPostStartupMessage is a hook to execute user functions after the startup message is printed (or skipped).
+func (h *Hooks) OnPostStartupMessage(handler ...OnPostStartupMessageHandler) {
+	h.app.mutex.Lock()
+	h.onPostStartup = append(h.onPostStartup, handler...)
+	h.app.mutex.Unlock()
+}
+
 // OnPreShutdown is a hook to execute user functions before Shutdown.
 func (h *Hooks) OnPreShutdown(handler ...OnPreShutdownHandler) {
 	h.app.mutex.Lock()
@@ -209,6 +398,26 @@
 	return nil
 }
 
+func (h *Hooks) executeOnPreStartupMessageHooks(data *PreStartupMessageData) error {
+	for _, handler := range h.onPreStartup {
+		if err := handler(data); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnPostStartupMessageHooks(data PostStartupMessageData) error {
+	for _, handler := range h.onPostStartup {
+		if err := handler(data); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (h *Hooks) executeOnPreShutdownHooks() {
 	for _, v := range h.onPreShutdown {
 		if err := v(); err != nil {