feat(mount id): Support custom mount ID and rationalize only-dir early (#4991)

Adding support for specifying a custom Mount ID to be included in mount instance id and refactors only-dir path rationalization so that it is normalized early during configuration processing.

Author: abhishek10004

cfg/config.go

@@ -523,6 +523,8 @@ type Config struct {
 
 	Metrics MetricsConfig `yaml:"metrics"`
 
+	MountId string `yaml:"mount-id"`
+
 	Mrd MrdConfig `yaml:"mrd"`
 
 	OnlyDir string `yaml:"only-dir"`
@@ -1340,6 +1342,12 @@ func BuildFlagSet(flagSet *pflag.FlagSet) error {
 		return err
 	}
 
+	flagSet.StringP("mount-id", "", "", "Custom identifier to be appended to the mount ID and printed in all logs.")
+
+	if err := flagSet.MarkHidden("mount-id"); err != nil {
+		return err
+	}
+
 	flagSet.IntP("mrd-pool-size", "", 4, "Specifies the MRD pool size to be used for zonal buckets. The value should be more than 0.")
 
 	if err := flagSet.MarkHidden("mrd-pool-size"); err != nil {
@@ -1975,6 +1983,10 @@ func BindFlags(v *viper.Viper, flagSet *pflag.FlagSet) error {
 		return err
 	}
 
+	if err := v.BindPFlag("mount-id", flagSet.Lookup("mount-id")); err != nil {
+		return err
+	}
+
 	if err := v.BindPFlag("mrd.pool-size", flagSet.Lookup("mrd-pool-size")); err != nil {
 		return err
 	}

cfg/params.yaml

@@ -1165,6 +1165,13 @@ params:
     default: "3"
     hide-flag: true
 
+  - config-path: "mount-id"
+    flag-name: "mount-id"
+    type: "string"
+    usage: "Custom identifier to be appended to the mount ID and printed in all logs."
+    default: ""
+    hide-flag: true
+
   - config-path: "mrd.pool-size"
     flag-name: "mrd-pool-size"
     type: "int"

cfg/rationalize.go

@@ -18,6 +18,7 @@ import (
 	"log"
 	"math"
 	"net/url"
+	"path"
 	"slices"
 	"strings"
 
@@ -166,6 +167,15 @@ func resolveGCSRetriesConfig(c *GcsRetriesConfig) {
 	}
 }
 
+// resolveOnlyDir normalizes OnlyDir to a clean relative path without leading
+// or trailing slashes (e.g., "foo/bar/.." -> "foo", "/foo/bar/" -> "foo/bar").
+func resolveOnlyDir(c *Config) {
+	if c.OnlyDir != "" {
+		clean := strings.TrimPrefix(path.Clean("/"+c.OnlyDir), "/")
+		c.OnlyDir = clean
+	}
+}
+
 // Rationalize updates the config fields based on the values of other fields.
 func Rationalize(v *viper.Viper, c *Config, optimizedFlags []string) error {
 	var err error
@@ -187,6 +197,7 @@ func Rationalize(v *viper.Viper, c *Config, optimizedFlags []string) error {
 	resolveParallelDownloadsValue(v, &c.FileCache, c)
 	resolveFileCacheAndBufferedReadConflict(v, c)
 	resolveGCSRetriesConfig(&c.GcsRetries)
+	resolveOnlyDir(c)
 
 	return nil
 }

cfg/rationalize_test.go

@@ -901,3 +901,31 @@ func TestRationalize_MetadataCacheConfig(t *testing.T) {
 		})
 	}
 }
+
+func TestResolveOnlyDir(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{"Clean relative path", "foo/bar", "foo/bar"},
+		{"Trailing slash", "foo/bar/", "foo/bar"},
+		{"Leading slash", "/foo/bar", "foo/bar"},
+		{"Leading and trailing slashes", "/foo/bar/", "foo/bar"},
+		{"Relative parent segment", "foo/../bar/", "bar"},
+		{"Root slash", "/", ""},
+		{"Root dot", "/.", ""},
+		{"Parent directory", "..", ""},
+		{"Root parent directory", "/..", ""},
+		{"Current directory prefix", "./foo", "foo"},
+		{"Parent directory prefix", "../foo", "foo"},
+		{"Empty string", "", ""},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			c := &Config{OnlyDir: tc.input}
+			resolveOnlyDir(c)
+			assert.Equal(t, tc.expected, c.OnlyDir)
+		})
+	}
+}

cmd/legacy_main.go

@@ -203,7 +203,7 @@ func mountWithArgs(bucketName string, mountPoint string, newConfig *cfg.Config,
 	// connection.
 	var storageHandle storage.StorageHandle
 	if bucketName != canned.FakeBucketName {
-		userAgent := getUserAgent(newConfig.AppName, getConfigForUserAgent(newConfig), logger.MountInstanceID(fsName(bucketName)))
+		userAgent := getUserAgent(newConfig.AppName, getConfigForUserAgent(newConfig), logger.MountInstanceID(fsName(bucketName), newConfig.MountId))
 		logger.Info("Creating Storage handle...")
 		storageHandle, err = createStorageHandle(newConfig, userAgent, metricHandle, isGKE, isDynamicMount(bucketName))
 		if err != nil {
@@ -388,7 +388,7 @@ func Mount(mountInfo *mountInfo, bucketName, mountPoint string) (err error) {
 
 	var logExporterShutdownFn common.ShutdownFn
 	if newConfig.Foreground {
-		err = logger.InitLogFile(newConfig.Logging, fsName(bucketName))
+		err = logger.InitLogFile(newConfig.Logging, fsName(bucketName), newConfig.MountId)
 		if err != nil {
 			return fmt.Errorf("init log file: %w", err)
 		}
@@ -397,14 +397,14 @@ func Mount(mountInfo *mountInfo, bucketName, mountPoint string) (err error) {
 			// startup configs and mount flags are captured. This is intentionally skipped
 			// in the ephemeral parent process to avoid double-initialization overhead.
 			// TODO: Update mount-id to use directory name as well in only dir mounting.
-			logExporterShutdownFn, err = monitor.SetupOTelLogExporter(context.Background(), newConfig.Logging.ExperimentalOtelLoggingEndpoint, logger.MountInstanceID(fsName(bucketName)), newConfig.GcsAuth, newConfig.Logging.ExperimentalOtelLoggingProjectId)
+			logExporterShutdownFn, err = monitor.SetupOTelLogExporter(context.Background(), newConfig.Logging.ExperimentalOtelLoggingEndpoint, logger.MountInstanceID(fsName(bucketName), newConfig.MountId), newConfig.GcsAuth, newConfig.Logging.ExperimentalOtelLoggingProjectId)
 			if err != nil {
 				logger.Errorf("Failed to setup OTel log exporter: %v", err)
 			}
 		}
 	}
 
-	logger.UpdateDefaultLogger(newConfig.Logging.Format, fsName(bucketName))
+	logger.UpdateDefaultLogger(newConfig.Logging.Format, fsName(bucketName), newConfig.MountId)
 
 	logger.Infof("Start gcsfuse/%s for app %q using mount point: %s\n", common.GetVersion(), newConfig.AppName, mountPoint)
 
@@ -475,12 +475,12 @@ func Mount(mountInfo *mountInfo, bucketName, mountPoint string) (err error) {
 	var metricExporterShutdownFn common.ShutdownFn
 	metricHandle := metrics.NewNoopMetrics()
 	if cfg.IsMetricsEnabled(&newConfig.Metrics) {
-		metricExporterShutdownFn = monitor.SetupOTelMetricExporters(ctx, newConfig, logger.MountInstanceID(fsName(bucketName)))
+		metricExporterShutdownFn = monitor.SetupOTelMetricExporters(ctx, newConfig, logger.MountInstanceID(fsName(bucketName), newConfig.MountId))
 		if metricHandle, err = metrics.NewOTelMetrics(ctx, int(newConfig.Metrics.Workers), int(newConfig.Metrics.BufferSize)); err != nil {
 			metricHandle = metrics.NewNoopMetrics()
 		}
 	}
-	shutdownTracingFn := monitor.SetupTracing(ctx, newConfig, logger.MountInstanceID(fsName(bucketName)))
+	shutdownTracingFn := monitor.SetupTracing(ctx, newConfig, logger.MountInstanceID(fsName(bucketName), newConfig.MountId))
 	traceHandle := tracing.NewNoopTracer()
 	if cfg.IsTracingEnabled(newConfig) {
 		traceHandle = tracing.NewOTELTracer()

cmd/mount.go

@@ -232,10 +232,10 @@ func getFuseMountConfig(fsName string, newConfig *cfg.Config) *fuse.MountConfig
 	// DEBUG         ERROR
 	// TRACE         TRACE
 	if newConfig.Logging.Severity.Rank() <= cfg.ErrorLogSeverity.Rank() {
-		mountCfg.ErrorLogger = logger.NewLegacyLogger(logger.LevelError, "fuse: ", fsName)
+		mountCfg.ErrorLogger = logger.NewLegacyLogger(logger.LevelError, "fuse: ", fsName, newConfig.MountId)
 	}
 	if newConfig.Logging.Severity.Rank() <= cfg.TraceLogSeverity.Rank() {
-		mountCfg.DebugLogger = logger.NewLegacyLogger(logger.LevelTrace, "fuse_debug: ", fsName)
+		mountCfg.DebugLogger = logger.NewLegacyLogger(logger.LevelTrace, "fuse_debug: ", fsName, newConfig.MountId)
 	}
 	return mountCfg
 }

internal/fs/fs_test.go

@@ -196,11 +196,11 @@ func (t *fsTest) SetUpTestSuite() {
 
 	// Initialize Fuse Loggers.
 	if mountCfg.ErrorLogger == nil {
-		mountCfg.ErrorLogger = logger.NewLegacyLogger(logger.LevelError, "fuse_errors: ", mountCfg.FSName)
+		mountCfg.ErrorLogger = logger.NewLegacyLogger(logger.LevelError, "fuse_errors: ", mountCfg.FSName, "")
 	}
 
 	if *fDebug {
-		mountCfg.DebugLogger = logger.NewLegacyLogger(logger.LevelDebug, "fuse: ", mountCfg.FSName)
+		mountCfg.DebugLogger = logger.NewLegacyLogger(logger.LevelDebug, "fuse: ", mountCfg.FSName, "")
 	}
 	// Mount the file system.
 	mfs, err = fuse.Mount(mntDir, server, &mountCfg)

internal/gcsx/bucket_manager.go

@@ -18,7 +18,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"path"
 	"time"
 
 	"github.com/googlecloudplatform/gcsfuse/v3/cfg"
@@ -208,7 +207,7 @@ func (bm *bucketManager) SetUpBucket(
 
 	// Limit to a requested prefix of the bucket, if any.
 	if bm.config.OnlyDir != "" {
-		b, err = NewPrefixBucket(path.Clean(bm.config.OnlyDir)+"/", b)
+		b, err = NewPrefixBucket(bm.config.OnlyDir+"/", b)
 		if err != nil {
 			err = fmt.Errorf("NewPrefixBucket: %w", err)
 			return

internal/logger/legacy_logger.go

@@ -27,8 +27,8 @@ import (
 // individual log messages.
 // This method is created to support jacobsa/fuse loggers and will be removed
 // after slog support is added.
-func NewLegacyLogger(level slog.Level, prefix, fsName string) *log.Logger {
-	handler := defaultLoggerFactory.handler(programLevel, prefix).WithAttrs(loggerAttr(fsName))
+func NewLegacyLogger(level slog.Level, prefix, fsName, customID string) *log.Logger {
+	handler := defaultLoggerFactory.handler(programLevel, prefix).WithAttrs(loggerAttr(fsName, customID))
 	logger := slog.NewLogLogger(handler, level)
 	setLoggingLevel(defaultLoggerFactory.level)
 	return logger

internal/logger/logger.go

@@ -62,7 +62,7 @@ var (
 // config.
 // Here, background true means, this InitLogFile has been called for the
 // background daemon.
-func InitLogFile(newLogConfig cfg.LoggingConfig, fsName string) error {
+func InitLogFile(newLogConfig cfg.LoggingConfig, fsName, customID string) error {
 	var f *os.File
 	var sysWriter *syslog.Writer
 	var fileWriter *lumberjack.Logger
@@ -106,7 +106,7 @@ func InitLogFile(newLogConfig cfg.LoggingConfig, fsName string) error {
 		logRotate:         newLogConfig.LogRotate,
 		enableOtelLogging: newLogConfig.ExperimentalEnableOtelLogging,
 	}
-	defaultLogger = defaultLoggerFactory.newLoggerWithMountInstanceID(string(newLogConfig.Severity), fsName)
+	defaultLogger = defaultLoggerFactory.newLoggerWithMountInstanceID(string(newLogConfig.Severity), fsName, customID)
 
 	return nil
 }
@@ -164,17 +164,20 @@ func MountUUID() string {
 }
 
 // MountInstanceID returns the InstanceID of current gcsfuse mount.
-// This is combination of `fsName` + MountUUID.
-// Note: fsName is passed here explicitly, as logger package doesn't know about fsName
+// This is combination of `fsName` + optional `customID` + MountUUID.
+// Note: fsName and customID are passed here explicitly, as logger package doesn't know about them
 // when MountInstanceID method is invoked.
-func MountInstanceID(fsName string) string {
+func MountInstanceID(fsName, customID string) string {
+	if customID != "" {
+		return fmt.Sprintf("%s-%s-%s", fsName, customID, MountUUID())
+	}
 	return fmt.Sprintf("%s-%s", fsName, MountUUID())
 }
 
 // UpdateDefaultLogger updates the log format and creates a new logger with MountInstanceID set as custom attribute.
-func UpdateDefaultLogger(format, fsName string) {
+func UpdateDefaultLogger(format, fsName, customID string) {
 	defaultLoggerFactory.format = format
-	defaultLogger = defaultLoggerFactory.newLoggerWithMountInstanceID(defaultLoggerFactory.level, fsName)
+	defaultLogger = defaultLoggerFactory.newLoggerWithMountInstanceID(defaultLoggerFactory.level, fsName, customID)
 }
 
 // Tracef prints the message with TRACE severity in the specified format.
@@ -279,13 +282,13 @@ func (f *loggerFactory) newLogger(level string) *slog.Logger {
 	return logger
 }
 
-func loggerAttr(fsName string) []slog.Attr {
-	return []slog.Attr{slog.String(MountIDKey, MountInstanceID(fsName))}
+func loggerAttr(fsName, customID string) []slog.Attr {
+	return []slog.Attr{slog.String(MountIDKey, MountInstanceID(fsName, customID))}
 }
 
 // create a new logger with mountInstanceID set as custom attribute on logger.
-func (f *loggerFactory) newLoggerWithMountInstanceID(level, fsName string) *slog.Logger {
-	logger := slog.New(f.handler(programLevel, "").WithAttrs(loggerAttr(fsName)))
+func (f *loggerFactory) newLoggerWithMountInstanceID(level, fsName, customID string) *slog.Logger {
+	logger := slog.New(f.handler(programLevel, "").WithAttrs(loggerAttr(fsName, customID)))
 	slog.SetDefault(logger)
 	setLoggingLevel(level)
 	return logger