void testJsonLoggingToggle() {
        logger.setJsonLoggingEnabled(true);
        logger.logAuthentication(true, "user", "DOMAIN", "192.168.1.1");

        logger.setJsonLoggingEnabled(false);
        logger.logAuthentication(true, "user2", "DOMAIN", "192.168.1.2");

        // Verify that both events were logged
        Map<EventType, Long> stats = logger.getStatistics();

          if (!buffer.isProbablyUtf8()) {
            logger.log("")
            logger.log("<-- END HTTP (${totalMs}ms, binary ${buffer.size}-byte body omitted)")
            return response
          }

          if (contentLength != 0L) {
            logger.log("")
            logger.log(buffer.clone().readString(charset))
          }

          logger.log(
            buildString {

		KeyFile:        tlsPrivateKey,
		CertFile:       tlsPublicCert,
		ExplicitFTPS:   tls,
		Logger:         &minioLogger{},
		PassivePorts:   portRange,
		PublicIP:       publicIP,
		ForceTLS:       forceTLS,
	})
	if err != nil {
		logger.Fatal(err, "unable to initialize FTP server")
	}

	logger.Info(fmt.Sprintf("%s listening on %s", name, net.JoinHostPort(publicIP, strconv.Itoa(port))))

            }
        } catch (final MalformedURLException e) {
            logger.warn("Could not parse url: {}", filePath, e);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Processing SmbFile: {}", filePath);
        }

        try {
            if (file == null) {

        }
    }

    // Test to verify the logger field is properly initialized
    public void test_loggerFieldInitialization() throws Exception {
        // Use reflection to access the private logger field
        Field loggerField = FessCurtainFinallyHook.class.getDeclaredField("logger");
        loggerField.setAccessible(true);

        Object logger = loggerField.get(null); // static field

		err = mergeDisksLayoutFromArgs(serverCmdArgs(ctx), ctxt)
	}

	return err
}

func handleCommonArgs(ctxt serverCtxt) {
	if ctxt.JSON {
		logger.EnableJSON()
	}
	if ctxt.Quiet {
		logger.EnableQuiet()
	}
	if ctxt.Anonymous {
		logger.EnableAnonymous()
	}

	consoleAddr := ctxt.ConsoleAddr
	addr := ctxt.Addr
	configDir := ctxt.ConfigDir
	configSet := ctxt.configDirSet

                    permissions = null;
                    if (logger.isDebugEnabled()) {
                        logger.debug("Token refreshed successfully via silent authentication");
                    }
                    return true;
                }
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Silent token refresh failed: {}", e.getMessage());

		ng.Go(ctx, func() error {
			// Give 15 seconds to each remote call.
			// Errors are logged but not returned.
			ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
			defer cancel()
			data, err := client.DownloadProfileData(ctx)
			if err != nil {
				reqInfo := (&logger.ReqInfo{}).AppendTags("peerAddress", client.host.String())
				ctx := logger.SetReqInfo(ctx, reqInfo)
				peersLogOnceIf(ctx, err, client.host.String())

import (
	"container/ring"
	"context"
	"io"
	"sync"
	"sync/atomic"

	"github.com/minio/madmin-go/v3"
	"github.com/minio/madmin-go/v3/logger/log"
	"github.com/minio/minio/internal/logger"
	"github.com/minio/minio/internal/logger/target/console"
	types "github.com/minio/minio/internal/logger/target/loggertypes"
	"github.com/minio/minio/internal/pubsub"
	xnet "github.com/minio/pkg/v3/net"
)

// number of log messages to buffer

	"github.com/minio/minio/internal/logger"
)

func proxyLogIf(ctx context.Context, err error, errKind ...any) {
	logger.LogIf(ctx, "proxy", err, errKind...)
}

func replLogIf(ctx context.Context, err error, errKind ...any) {
	logger.LogIf(ctx, "replication", err, errKind...)
}

func replLogOnceIf(ctx context.Context, err error, id string, errKind ...any) {
	logger.LogOnceIf(ctx, "replication", err, id, errKind...)
}