The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

log/log.go (3)

11-18: Solid internal abstraction, but consider documenting variance limitations

Defining a non-generic baseLogger lets you keep a single global while exposing generics publicly. Please add a short note in the comment that values stored in logger must implement AllLogger[T] for their concrete T (no covariance), so callers should not expect DefaultLogger[any]() to succeed. This will preempt misuse down the line.

---

80-86: Consider a typed variant of WithContext for power users

WithContext(ctx) CommonLogger preserves the old surface, but it discards the type information. Consider adding an optional WithContextT[T any](ctx) AllLogger[T] (or a method on concrete implementations) so users can still access typed underlying loggers after binding a context.

---

104-119: Minor naming nit: strs -> levelPrefixes

strs is a bit vague. A more descriptive name would improve readability.

- var strs = []string{
+ var levelPrefixes = []string{
@@
-func (lv Level) toString() string {
+func (lv Level) toString() string {
-   if lv >= LevelTrace && lv <= LevelPanic {
-       return strs[lv]
+   if lv >= LevelTrace && lv <= LevelPanic {
+       return levelPrefixes[lv]
    }

docs/whats_new.md (1)

1881-1884: Add a caution about generics variance to prevent misuse

Please add a one-liner that AllLogger[T] is not covariant: implementations usually satisfy AllLogger[*log.Logger] (std lib), not AllLogger[any]. Users should use the concrete underlying type (e.g., *log.Logger) when calling DefaultLogger[T].

 #### 🧾 Log
-
-The `ConfigurableLogger` and `AllLogger` interfaces now use generics. You can specify the underlying logger type when implementing these interfaces or use `any` for maximum flexibility. `log.SetLogger` and `log.DefaultLogger` also accept a type parameter, so the concrete logger can be retrieved and used directly, for example `log.DefaultLogger[*MyLogger]().Logger()`.
+The `ConfigurableLogger` and `AllLogger` interfaces now use generics. Specify the concrete underlying logger type (e.g., `*log.Logger`) when implementing or retrieving defaults. Note: `AllLogger[T]` is not covariant—using `any` as `T` will not match implementations built for a concrete `T`. `log.SetLogger` and `log.DefaultLogger` accept a type parameter; for example, `log.DefaultLogger[*log.Logger]().Logger()`.

docs/api/log.md (1)

28-53: Interfaces look correct; minor duplication

Turning ConfigurableLogger and AllLogger into generics is on point. Note AllLogger[T] embeds CommonLogger (which already embeds WithLogger), so the extra WithLogger line in AllLogger[T] is redundant. Not wrong, just repetitive.

 type AllLogger[T any] interface {
     CommonLogger
     ConfigurableLogger[T]
-    WithLogger
 }

log/fiberlog.go (3)

78-82: Clarify repetitive “w”-method docstrings

The phrase “pairs are treated as they are privateLog With.” is awkward and unclear across Tracew/Debugw/Infow/Warnw/Errorw/Fatalw/Panicw. Suggest a concise, consistent phrasing.

Example diff for one occurrence (apply similarly to all “w” variants):

-// Tracew logs a message with some additional context. The variadic key-value
-// pairs are treated as they are privateLog With.
+// Tracew logs a message with additional key-value context (same semantics as With).

Also applies to: 84-88, 90-94, 96-100, 102-106, 108-112, 114-118

---

126-129: SetLogger is not concurrency-safe; benches call it in parallel

The comment correctly states non-concurrency-safety. However, Benchmark_SetLogger_Parallel exercises SetLogger concurrently in tests, which will race under -race. Consider keeping the benchmark but add a note or a build tag to skip with -race, or make the global swap atomic if you want to support concurrent reconfiguration.

Option A: Keep as-is, add a clarifying comment in the benchmark.
Option B (heavier): Use atomic.Value for the global logger to make swaps race-free.

If you want to explore Option B later, I can draft it behind an internal helper to avoid public API changes.

---

120-122: Typed WithContext returns CommonLogger — document type erasure

WithContext returns CommonLogger (non-generic), which erases the type parameter. That’s fine per log.go’s interface, but please ensure docs mention that typed accessors (like Logger()) won’t be available on the returned value.

log/fiberlog_test.go (2)

149-162: Parallel SetLogger will race under -race

This intentionally stresses SetLogger, but it will deterministically flag a data race under -race (as documented by the API). Consider skipping this benchmark when -race is enabled.

Apply this diff to add a guard:

 func Benchmark_SetLogger_Parallel(b *testing.B) {
+	if raceEnabled() { // helper that returns true under -race, see below
+		b.Skip("SetLogger is not concurrency-safe; skip under -race")
+	}
 	setLog := &defaultLogger{
 		stdlog: log.New(os.Stderr, "", log.LstdFlags|log.Lshortfile|log.Lmicroseconds),
 		depth:  6,
 	}
@@
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
 			SetLogger(setLog)
 		}
 	})
 }
+
+// place near tests:
+func raceEnabled() bool { return false } // replaced at build-time with -tags race via a file with `package log; func raceEnabled() bool { return true }`

---

201-211: Parallel SetLevel mutates shared state without sync

SetLevel writes to mockLogger.level; concurrent calls can race under -race. Either keep (documented) or isolate from -race runs similar to SetLogger.

middleware/logger/utils.go (2)

45-48: Generic parameter T is unused in writer; consider narrowing to CommonLogger

customLoggerWriter[T] stores AllLogger[T] but only uses CommonLogger methods. You can simplify API and avoid unnecessary generic instantiation by accepting fiberlog.CommonLogger instead. This avoids monomorphization and reduces surface area.

Example:

-type customLoggerWriter[T any] struct {
-	loggerInstance fiberlog.AllLogger[T]
+type customLoggerWriter struct {
+	loggerInstance fiberlog.CommonLogger
 	level          fiberlog.Level
 }

And adjust LoggerToWriter accordingly (see below).

---

72-87: Broaden level validation to future-proof against out-of-range values

You panic for Fatal/Panic, but other invalid ints could slip through if Level gains values or callers pass arbitrary ints. Validate the permitted range explicitly.

If Level values are contiguous from LevelTrace to LevelError:

-func LoggerToWriter[T any](logger fiberlog.AllLogger[T], level fiberlog.Level) io.Writer {
+func LoggerToWriter[T any](logger fiberlog.AllLogger[T], level fiberlog.Level) io.Writer {
 	// Check if customLogger is nil
 	if logger == nil {
 		fiberlog.Panic("LoggerToWriter: customLogger must not be nil")
 	}
 
 	// Check if level is valid
-	if level == fiberlog.LevelFatal || level == fiberlog.LevelPanic {
+	if level < fiberlog.LevelTrace || level > fiberlog.LevelError {
 		fiberlog.Panic("LoggerToWriter: invalid level")
 	}
 
-	return &customLoggerWriter[T]{
+	return &customLoggerWriter[T]{
 		level:          level,
 		loggerInstance: logger,
 	}
 }

If you adopt the CommonLogger simplification, also change the return to &customLoggerWriter{...} and the argument type to fiberlog.CommonLogger.

log/default.go (3)

22-24: Docstrings: minor grammar fixes

“logs a message at a given level log the default logger.” → “logs a message at the given level using the default logger.”

-// privateLog logs a message at a given level log the default logger.
+// privateLog logs a message at the given level using the default logger.
...
-// privateLog logs a message at a given level log the default logger.
+// privateLogf logs a message at the given level using the default logger.
...
-// privateLog logs a message at a given level log the default logger.
+// privateLogw logs a message at the given level using the default logger.

Also applies to: 45-47, 72-74

---

29-43: Ensure pooled buffer is returned on panic paths

In privateLog/privateLogf/privateLogw, a panic occurs before the buffer is returned to the pool. Use a defer to always Reset+Put even on panic.

Apply this pattern to all three functions:

 	buf := bytebufferpool.Get()
+	defer func() {
+		buf.Reset()
+		bytebufferpool.Put(buf)
+	}()
 	buf.WriteString(level)
 	// ...
-	_ = l.stdlog.Output(l.depth, buf.String()) //nolint:errcheck // It is fine to ignore the error
-	if lv == LevelPanic {
-		panic(buf.String())
-	}
-	buf.Reset()
-	bytebufferpool.Put(buf)
+	_ = l.stdlog.Output(l.depth, buf.String()) //nolint:errcheck // It is fine to ignore the error
+	if lv == LevelPanic {
+		panic(buf.String())
+	}
 	if lv == LevelFatal {
 		os.Exit(1) //nolint:revive // we want to exit the program when Fatal is called
 	}

Note: os.Exit bypasses defers, but you already Put the buffer before Exit; keep that sequencing.

Also applies to: 51-70, 79-111

---

218-221: DefaultLogger: handle failed type assertion explicitly (and quiet linters)

Returning a nil typed interface when the assertion fails is fine, but being explicit improves readability and can address static analysis noise.

Apply:

-func DefaultLogger[T any]() AllLogger[T] {
-	l, _ := logger.(AllLogger[T])
-	return l
-}
+func DefaultLogger[T any]() AllLogger[T] {
+	if l, ok := logger.(AllLogger[T]); ok {
+		return l
+	}
+	return nil
+}

If errcheck flagged this line (hint suggests so), confirm the warning disappears with this change.

middleware/logger/logger_test.go (1)

1104-1110: Benchmarks use typed DefaultLogger and LoggerToWriter correctly

Good coverage for the generic path in both serial and parallel benches. If you adopt the CommonLogger simplification in LoggerToWriter, the benchmark call sites won’t need generics.

Also applies to: 1259-1265

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: ReneWerner87
PR: gofiber/fiber#3161
File: app.go:923-932
Timestamp: 2024-11-15T07:56:21.623Z
Learning: In the Fiber framework, breaking changes are acceptable when moving from version 2 to version 3, including modifications to method signatures such as in the `Test` method in `app.go`.

log/log.go (2)

20-23: Global default uses std log with rich flags — LGTM

Good defaults: stderr + LstdFlags|Lshortfile|Lmicroseconds and depth: 4.

---

65-76: Typed Logger() T is the right call

Changing ConfigurableLogger to ConfigurableLogger[T] with Logger() T eliminates unsafe assertions on the consumer side. Nice.

docs/whats_new.md (2)

986-989: Good overview of the new typed logger surface

Clear statement of AllLogger[T] + Logger().

---

1413-1413: Index update for Log migration — LGTM

Anchor aligns with the new section.

docs/api/log.md (4)

120-121: Nice compile-time guarantee

var _ fiberlog.AllLogger[*log.Logger] = (*customLogger)(nil) is a good interface guard.

---

129-132: Typed SetLogger example — LGTM

Using SetLogger[*log.Logger] demonstrates the generic API well.

---

133-136: Good: direct typed access to std logger

DefaultLogger[*log.Logger]().Logger() removing runtime assertions is exactly the benefit users need.

---

211-215: Typed retrieval section — LGTM

Clear and accurate.

log/default_test.go (1)

233-236: Test now reflects typed Logger() — LGTM

Dropping the runtime type assertion is correct after making Logger() return a concrete *log.Logger.

log/fiberlog_test.go (3)

13-15: Typed DefaultLogger usage LGTM

Switching to DefaultLogger*log.Logger removes runtime type assertions and is consistent with the new API.

---

73-78: Benchmark DefaultSystemLogger typed call LGTM

Using the typed DefaultLogger in the benchmark is consistent and keeps allocations observable.

---

139-147: Parallel read of DefaultLogger is fine; ensure no concurrent SetLogger during this bench

Reading the global logger concurrently is benign if no concurrent writers. Keep this bench isolated from SetLogger concurrent benches when running with -race.

log/default.go (2)

214-216: Logger() return type LGTM

Returning *log.Logger directly improves ergonomics and removes type assertions in tests and examples.

---

14-14: Compile-time assertion LGTM

Asserting defaultLogger implements AllLogger[*log.Logger] ensures API coherence after the generics shift.

middleware/logger/logger_test.go (2)

344-346: Typed DefaultLogger + direct std logger access LGTM

Using DefaultLogger[*log.Logger] and then Logger() avoids reflection and clarifies intent.

---

381-384: LoggerToWriter generic usage and panic tests LGTM

Typed invocation matches the new signature; invalid level and nil logger panics are well-covered.

Also applies to: 396-406