or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

index.md

tile.json

tessl/maven-org-slf4j--slf4j-nop

SLF4J NOP Provider - A no-operation implementation of the SLF4J logging facade that silently discards all logging operations

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:maven/org.slf4j/slf4j-nop@2.0.x

To install, run

npx @tessl/cli install tessl/maven-org-slf4j--slf4j-nop@2.0.0

SLF4J NOP Provider

SLF4J NOP Provider is a specialized implementation of the Simple Logging Facade for Java (SLF4J) that provides no-operation logging behavior. All logging operations are silently discarded without any output or side effects, making it ideal for applications that need to satisfy SLF4J API dependencies while completely disabling logging functionality.

Package Information

Package Name: slf4j-nop
Package Type: Maven
Group ID: org.slf4j
Artifact ID: slf4j-nop
Language: Java
Installation: Add to Maven pom.xml: <dependency><groupId>org.slf4j</groupId><artifactId>slf4j-nop</artifactId><version>2.0.17</version></dependency>

Core Imports

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
import org.slf4j.MDC;

Basic Usage

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyApplication {
    private static final Logger logger = LoggerFactory.getLogger(MyApplication.class);
    
    public void doSomething() {
        // All logging calls are silently discarded - zero performance overhead
        logger.info("This message will be discarded");
        logger.debug("Debug information - also discarded");
        logger.error("Even errors are discarded");
        
        // Level checks always return false
        if (logger.isDebugEnabled()) { // Always false
            // This block never executes
            logger.debug("Expensive debug operation");
        }
    }
}

Architecture

The NOP provider implements the SLF4J Service Provider Interface (SPI) with no-operation behavior:

NOPServiceProvider: Main service provider that implements SLF4JServiceProvider
NOPLoggerFactory: Returns singleton NOP logger instances
NOPLogger: All logging methods are no-ops, level checks return false
NOPMDCAdapter: Mapped Diagnostic Context operations have no effect

Capabilities

Logger Factory

Access to logger instances through the standard SLF4J factory pattern.

public class LoggerFactory {
    public static Logger getLogger(String name);
    public static Logger getLogger(Class<?> clazz);
}

Logger Interface

All logging methods are implemented as no-operations that silently discard input.

public interface Logger {
    // Level checking methods - all return false
    boolean isTraceEnabled();
    boolean isDebugEnabled();
    boolean isInfoEnabled();
    boolean isWarnEnabled();
    boolean isErrorEnabled();
    boolean isTraceEnabled(Marker marker);
    boolean isDebugEnabled(Marker marker);
    boolean isInfoEnabled(Marker marker);
    boolean isWarnEnabled(Marker marker);
    boolean isErrorEnabled(Marker marker);
    
    // Basic logging methods - all no-ops
    void trace(String msg);
    void trace(String format, Object arg);
    void trace(String format, Object arg1, Object arg2);
    void trace(String format, Object... arguments);
    void trace(String msg, Throwable t);
    
    void debug(String msg);
    void debug(String format, Object arg);
    void debug(String format, Object arg1, Object arg2);
    void debug(String format, Object... arguments);
    void debug(String msg, Throwable t);
    
    void info(String msg);
    void info(String format, Object arg);
    void info(String format, Object arg1, Object arg2);
    void info(String format, Object... arguments);
    void info(String msg, Throwable t);
    
    void warn(String msg);
    void warn(String format, Object arg);
    void warn(String format, Object arg1, Object arg2);
    void warn(String format, Object... arguments);
    void warn(String msg, Throwable t);
    
    void error(String msg);
    void error(String format, Object arg);
    void error(String format, Object arg1, Object arg2);
    void error(String format, Object... arguments);
    void error(String msg, Throwable t);
    
    // Marker-based logging methods - all no-ops
    void trace(Marker marker, String msg);
    void trace(Marker marker, String format, Object arg);
    void trace(Marker marker, String format, Object arg1, Object arg2);
    void trace(Marker marker, String format, Object... arguments);
    void trace(Marker marker, String msg, Throwable t);
    
    void debug(Marker marker, String msg);
    void debug(Marker marker, String format, Object arg);
    void debug(Marker marker, String format, Object arg1, Object arg2);
    void debug(Marker marker, String format, Object... arguments);
    void debug(Marker marker, String msg, Throwable t);
    
    void info(Marker marker, String msg);
    void info(Marker marker, String format, Object arg);
    void info(Marker marker, String format, Object arg1, Object arg2);
    void info(Marker marker, String format, Object... arguments);
    void info(Marker marker, String msg, Throwable t);
    
    void warn(Marker marker, String msg);
    void warn(Marker marker, String format, Object arg);
    void warn(Marker marker, String format, Object arg1, Object arg2);
    void warn(Marker marker, String format, Object... arguments);
    void warn(Marker marker, String msg, Throwable t);
    
    void error(Marker marker, String msg);
    void error(Marker marker, String format, Object arg);
    void error(Marker marker, String format, Object arg1, Object arg2);
    void error(Marker marker, String format, Object... arguments);
    void error(Marker marker, String msg, Throwable t);
    
    // Utility method
    String getName(); // Returns "NOP"
}

Marker Factory

Creates markers for tagged logging (markers function normally, but tagged logging calls are still discarded).

public class MarkerFactory {
    public static Marker getMarker(String name);
}

Mapped Diagnostic Context (MDC)

Provides contextual information storage - all operations are no-ops in NOP provider.

public class MDC {
    public static void put(String key, String val); // No-op
    public static String get(String key); // Always returns null
    public static void remove(String key); // No-op
    public static void clear(); // No-op
    public static MDCCloseable putCloseable(String key, String val); // Returns no-op closeable
    
    public interface MDCCloseable extends AutoCloseable {
        void close(); // No-op
    }
}

Service Provider Interface

Internal SPI implementation - not typically used directly by applications.

public interface SLF4JServiceProvider {
    ILoggerFactory getLoggerFactory();
    IMarkerFactory getMarkerFactory();
    MDCAdapter getMDCAdapter();
    String getRequestedApiVersion();
    void initialize();
}

public class NOPServiceProvider implements SLF4JServiceProvider {
    public static final String REQUESTED_API_VERSION = "2.0.99";
    
    public NOPServiceProvider();
    public ILoggerFactory getLoggerFactory();
    public IMarkerFactory getMarkerFactory();
    public MDCAdapter getMDCAdapter();
    public String getRequestedApiVersion();
    public void initialize(); // No-op
}

Types

public interface Marker extends java.io.Serializable {
    String getName();
    void add(Marker reference);
    boolean remove(Marker reference);
    boolean hasChildren();
    boolean hasReferences();
    Iterator<Marker> iterator();
    boolean contains(Marker other);
    boolean contains(String name);
}

public interface ILoggerFactory {
    Logger getLogger(String name);
}

public interface IMarkerFactory {
    Marker getMarker(String name);
    boolean exists(String name);
    boolean detachMarker(String name);
    Marker getDetachedMarker(String name);
}

public interface MDCAdapter {
    void put(String key, String val);
    String get(String key);
    void remove(String key);
    void clear();
    Map<String, String> getCopyOfContextMap();
    void setContextMap(Map<String, String> contextMap);
    void pushByKey(String key, String value);
    String popByKey(String key);
    Deque<String> getCopyOfDequeByKey(String key);
    void clearDequeByKey(String key);
}

Usage Examples

Basic Logging

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BusinessLogic {
    private static final Logger logger = LoggerFactory.getLogger(BusinessLogic.class);
    
    public void processOrder(String orderId) {
        logger.info("Processing order: {}", orderId); // Silently discarded
        
        try {
            // Business logic here
            logger.debug("Order processing completed"); // Silently discarded
        } catch (Exception e) {
            logger.error("Failed to process order: " + orderId, e); // Silently discarded
        }
    }
}

Marker-based Logging

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;

public class SecurityService {
    private static final Logger logger = LoggerFactory.getLogger(SecurityService.class);
    private static final Marker SECURITY = MarkerFactory.getMarker("SECURITY");
    
    public void authenticate(String username) {
        logger.info(SECURITY, "Authentication attempt for user: {}", username); // Silently discarded
        
        // Authentication logic
        logger.warn(SECURITY, "Failed login attempt for: {}", username); // Silently discarded
    }
}

Conditional Logging

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DataProcessor {
    private static final Logger logger = LoggerFactory.getLogger(DataProcessor.class);
    
    public void processData(List<String> data) {
        // Performance optimization - check if debug is enabled before expensive operations
        if (logger.isDebugEnabled()) { // Always returns false with NOP provider
            // This block never executes, avoiding expensive string operations
            logger.debug("Processing {} items: {}", data.size(), data.toString());
        }
        
        // Process data...
    }
}

MDC Context

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

public class RequestProcessor {
    private static final Logger logger = LoggerFactory.getLogger(RequestProcessor.class);
    
    public void handleRequest(String requestId) {
        MDC.put("requestId", requestId); // No-op
        
        try {
            logger.info("Handling request"); // Silently discarded
            // Request processing logic
        } finally {
            MDC.clear(); // No-op
        }
    }
    
    public void handleRequestWithCloseable(String requestId) {
        try (MDC.MDCCloseable closeable = MDC.putCloseable("requestId", requestId)) { // Returns no-op closeable
            logger.info("Handling request with closeable MDC"); // Silently discarded
            // Request processing logic
        } // Closeable.close() is no-op
    }
}

Error Handling

The NOP provider does not throw any exceptions from logging operations. All methods silently accept and discard input parameters. This ensures that applications remain functional even when logging is completely disabled.

Common patterns:

All logging method calls succeed silently
Level check methods always return false
MDC operations have no effect and get() always returns null
No configuration is required or possible