refactor: better names for Must* funcs

boxo/autoconfig/README.md

@@ -146,9 +146,9 @@ $CACHE_DIR/
 The client implements graceful fallback:
 1. Try to fetch from remote URL
 2. If remote fails, fall back to latest cached version
-3. If no cache exists, fall back to provided defaults (when using `MustGetConfig`)
+3. If no cache exists, fall back to provided defaults (when using `MustGetConfigCached` or `MustGetConfigWithRefresh`)
 
-Note: `GetLatest()` returns errors, while `MustGetConfig()` never fails and always returns usable configuration.
+Note: `GetLatest()` returns errors, while `MustGetConfigCached()` and `MustGetConfigWithRefresh()` never fail and always return usable configuration.
 
 ## Testing
 

boxo/autoconfig/fetch.go

@@ -34,14 +34,13 @@ func (c *Client) getLatest(ctx context.Context, configURL string, refreshInterva
 	// Check if we have cached data that's still within refreshInterval
 	cachedResp, cacheErr := c.getCached(cacheDir)
 	if cacheErr == nil && cachedResp.CacheAge < refreshInterval {
-		freshFor := refreshInterval - cachedResp.CacheAge
-		log.Debugf("using cached autoconfig (age: %s, fresh for %s)", formatDuration(cachedResp.CacheAge), formatDuration(freshFor))
+		log.Debugf("using cached autoconfig within refresh interval")
 		return cachedResp, nil
 	}
 
 	// Cache is stale or doesn't exist, try to fetch from remote
 	if cacheErr == nil {
-		log.Debugf("cache stale (age: %s), checking for updates", formatDuration(cachedResp.CacheAge))
+		log.Debugf("cache stale, checking for updates")
 	}
 	resp, err := c.fetchFromRemote(ctx, configURL, cacheDir)
 	if err != nil {
@@ -59,19 +58,17 @@ func (c *Client) getLatest(ctx context.Context, configURL string, refreshInterva
 	if resp.Config != nil && cacheErr == nil {
 		effectiveInterval := calculateEffectiveRefreshInterval(refreshInterval, resp.Config.CacheTTL)
 		if effectiveInterval < refreshInterval {
-			log.Debugf("server CacheTTL (%ds) is shorter than user refresh interval (%s), using effective interval %s",
-				resp.Config.CacheTTL, refreshInterval, effectiveInterval)
+			log.Debugf("server CacheTTL is shorter than user refresh interval, using server CacheTTL")
 
 			// Re-check if cached version is still fresh under the effective (shorter) interval
 			if cachedResp.CacheAge < effectiveInterval {
-				log.Debugf("cached config is still fresh under server CacheTTL (%s)", effectiveInterval)
+				log.Debugf("cached config is still fresh under server CacheTTL")
 				return cachedResp, nil
 			}
 			// If cached version is also stale under server TTL, continue with newly fetched config
 			log.Debugf("cached config is stale even under server CacheTTL, using newly fetched config")
 		} else {
-			log.Debugf("using user refresh interval (%s), server CacheTTL (%ds) is longer or not specified",
-				refreshInterval, resp.Config.CacheTTL)
+			log.Debugf("using user refresh interval, server CacheTTL is longer or not specified")
 		}
 	}
 
@@ -83,11 +80,11 @@ func (c *Client) getLatest(ctx context.Context, configURL string, refreshInterva
 	return resp, nil
 }
 
-// MustGetConfigOffline returns config from cache or fallback without any network I/O.
+// MustGetConfigCached returns config from cache or fallback without any network I/O.
 //
 // This method guarantees no network operations will be performed, making it safe to
-// call from any context, including offline nodes and config validation routines.
-// It follows this priority order:
+// call from any context where network access should be avoided. It only uses locally
+// cached data or the provided fallback. It follows this priority order:
 //
 // 1. Return cached config if available (regardless of age)
 // 2. Call provided fallback function if cache miss occurs
@@ -96,10 +93,10 @@ func (c *Client) getLatest(ctx context.Context, configURL string, refreshInterva
 // This method is essential for preventing network blocking during config reads,
 // especially in scenarios where autoconfig is enabled but network access should
 // be avoided (e.g., config validation, offline node construction).
-func (c *Client) MustGetConfigOffline(configURL string, fallbackFunc func() *Config) *Config {
+func (c *Client) MustGetConfigCached(configURL string, fallbackFunc func() *Config) *Config {
 	cacheDir, err := c.getCacheDir(configURL)
 	if err != nil {
-		log.Debugf("MustGetConfigOffline: cache dir error: %v, using fallback", err)
+		log.Debugf("MustGetConfigCached: cache dir error: %v, using fallback", err)
 		if fallbackFunc != nil {
 			return fallbackFunc()
 		}
@@ -109,18 +106,18 @@ func (c *Client) MustGetConfigOffline(configURL string, fallbackFunc func() *Con
 	// Try to get from cache only
 	config, err := c.getCachedConfig(cacheDir)
 	if err != nil {
-		log.Debugf("MustGetConfigOffline: cache miss or error: %v, using fallback", err)
+		log.Debugf("MustGetConfigCached: cache miss or error: %v, using fallback", err)
 		if fallbackFunc != nil {
 			return fallbackFunc()
 		}
 		return GetMainnetFallbackConfig()
 	}
 
-	log.Debugf("MustGetConfigOffline: returning cached config")
+	log.Debugf("MustGetConfigCached: returning cached config")
 	return config
 }
 
-// MustGetConfigOnline fetches the latest config from network with fallback handling.
+// MustGetConfigWithRefresh fetches the latest config from network with fallback handling.
 //
 // This method will attempt to fetch fresh config from the network, respecting the
 // refreshInterval for cache freshness. If network fetch fails, it falls back to:
@@ -129,22 +126,29 @@ func (c *Client) MustGetConfigOffline(configURL string, fallbackFunc func() *Con
 // 3. Default mainnet fallback
 //
 // This method may block on network I/O and should be used when network operations
-// are acceptable. For config reads that must avoid network I/O, use MustGetConfigOffline.
-func (c *Client) MustGetConfigOnline(ctx context.Context, configURL string, refreshInterval time.Duration, fallbackFunc func() *Config) *Config {
+// are acceptable. For config reads that must avoid network I/O, use MustGetConfigCached.
+func (c *Client) MustGetConfigWithRefresh(ctx context.Context, configURL string, refreshInterval time.Duration, fallbackFunc func() *Config) *Config {
 	resp, err := c.getLatest(ctx, configURL, refreshInterval)
 	if err != nil {
 		log.Errorf("AutoConfig fetch failed: %v, falling back to provided fallback config", err)
 	} else if resp == nil || resp.Config == nil {
 		log.Errorf("AutoConfig fetch returned nil response or config, falling back to provided fallback config")
 	} else {
 		// Return the fetched config as-is without any modification
+		if resp.FromCache {
+			log.Debugf("MustGetConfigWithRefresh: returning cached config")
+		} else {
+			log.Debugf("MustGetConfigWithRefresh: returning fresh config from network")
+		}
 		return resp.Config
 	}
 
 	// Use the provided fallback function if available, otherwise use default mainnet fallback
 	if fallbackFunc != nil {
+		log.Debugf("MustGetConfigWithRefresh: returning provided fallback config")
 		return fallbackFunc()
 	}
+	log.Debugf("MustGetConfigWithRefresh: returning default mainnet fallback config")
 	return GetMainnetFallbackConfig()
 }
 

boxo/autoconfig/updater.go

@@ -110,7 +110,7 @@ func (u *BackgroundUpdater) Start(ctx context.Context) error {
 	u.wg.Add(1)
 	go u.runUpdater()
 
-	log.Debugf("started autoconfig background updater with interval %v", u.updateInterval)
+	log.Debugf("started autoconfig background updater")
 	return nil
 }
 
@@ -167,7 +167,7 @@ func (u *BackgroundUpdater) runUpdater() {
 			} else {
 				// Success - reset failure count
 				if failureCount > 0 {
-					log.Debugf("autoconfig background update succeeded after %d failed attempts", failureCount)
+					log.Debugf("autoconfig background update succeeded after retries")
 					failureCount = 0
 				} else {
 					log.Debug("autoconfig background update succeeded")

cmd/ipfs/kubo/daemon.go

@@ -1311,7 +1311,7 @@ func startAutoConfigUpdater(ctx context.Context, cfg *config.Config, userAgent s
 		primeCtx, cancel := context.WithTimeout(ctx, config.DefaultAutoconfigTimeout)
 		defer cancel()
 
-		result := client.MustGetConfigOnline(primeCtx, autoConfigURL, refreshInterval, autoconfig.GetMainnetFallbackConfig)
+		result := client.MustGetConfigWithRefresh(primeCtx, autoConfigURL, refreshInterval, autoconfig.GetMainnetFallbackConfig)
 		if result != nil {
 			autoconfigLog.Debugf("successfully primed autoconfig cache with version %d", result.AutoConfigVersion)
 		}

config/autoconfig.go

@@ -236,8 +236,7 @@ func (c *Config) BootstrapWithAutoConfig() []string {
 		routingType := c.Routing.Type.WithDefault(DefaultRoutingType)
 		nativeSystems := GetNativeSystems(routingType)
 		autoConfigData = autoConfig.GetBootstrapPeers(nativeSystems)
-		log.Debugf("BootstrapWithAutoConfig: routingType=%s nativeSystems=%v peers=%d",
-			routingType, nativeSystems, len(autoConfigData))
+		log.Debugf("BootstrapWithAutoConfig: processing with routing type: %s", routingType)
 	} else {
 		log.Debugf("BootstrapWithAutoConfig: autoConfig disabled, using original config")
 	}
@@ -306,11 +305,11 @@ func (c *Config) getAutoConfig() *autoconfig.Config {
 		return nil
 	}
 
-	// Use MustGetConfigOffline to avoid network I/O during config operations
-	// This ensures offline nodes don't block on network operations
-	result := client.MustGetConfigOffline(c.AutoConfig.URL, autoconfig.GetMainnetFallbackConfig)
+	// Use MustGetConfigCached to avoid network I/O during config operations
+	// This ensures config retrieval doesn't block on network operations
+	result := client.MustGetConfigCached(c.AutoConfig.URL, autoconfig.GetMainnetFallbackConfig)
 
-	log.Debugf("getAutoConfig: returning config with %d DelegatedEndpoints", len(result.DelegatedEndpoints))
+	log.Debugf("getAutoConfig: returning autoconfig data")
 	return result
 }
 

config/autoconfig_client.go

@@ -43,13 +43,13 @@ func NewAutoConfigClientWithConfig(repoPath string, cfg interface{}, userAgent s
 }
 
 // GetAutoConfig is a convenience function to get the latest config with a default client
-// Uses the default check interval - for user-configured intervals, use MustGetConfigOnline directly
+// Uses the default check interval - for user-configured intervals, use MustGetConfigWithRefresh directly
 func GetAutoConfig(ctx context.Context, configURL, repoPath, userAgent string) (*autoconfig.Config, error) {
 	client, err := NewAutoConfigClient(repoPath, userAgent)
 	if err != nil {
 		return nil, err
 	}
-	return client.MustGetConfigOnline(ctx, configURL, autoconfig.DefaultRefreshInterval, autoconfig.GetMainnetFallbackConfig), nil
+	return client.MustGetConfigWithRefresh(ctx, configURL, autoconfig.DefaultRefreshInterval, autoconfig.GetMainnetFallbackConfig), nil
 }
 
 

test/cli/autoconfig/fuzz_test.go

@@ -25,7 +25,7 @@ func testAutoConfigWithFallbackAndTimeout(t *testing.T, serverURL string, expect
 	client, err := autoconfig.NewClient(autoconfig.WithUserAgent("test-agent"))
 	require.NoError(t, err)
 
-	// Use fallback detection to test error conditions with MustGetConfigOnline
+	// Use fallback detection to test error conditions with MustGetConfigWithRefresh
 	fallbackUsed := false
 	fallbackConfig := &autoconfig.Config{
 		AutoConfigVersion: -999, // Special marker to detect fallback usage
@@ -34,7 +34,7 @@ func testAutoConfigWithFallbackAndTimeout(t *testing.T, serverURL string, expect
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
-	result := client.MustGetConfigOnline(ctx, serverURL, autoconfig.DefaultRefreshInterval, func() *autoconfig.Config {
+	result := client.MustGetConfigWithRefresh(ctx, serverURL, autoconfig.DefaultRefreshInterval, func() *autoconfig.Config {
 		fallbackUsed = true
 		return fallbackConfig
 	})