Set Logging Level in Spring Boot via Environment Variable for Flexible Debugging and Production Monitoring

Spring Boot automatically maps environment variables to configuration properties. To set a logging level, you can use:

1. Directly via SPRING_APPLICATION_JSON

You can pass JSON through the environment variable SPRING_APPLICATION_JSON:

export SPRING_APPLICATION_JSON='{"logging":{"level":{"root":"DEBUG"}}}'

Now, when the application runs, it will use the DEBUG level globally.

2. Using Standard Environment Variable Convention

Spring Boot allows converting property names into environment variables using uppercase letters and underscores. For example:

export LOGGING_LEVEL_ROOT=DEBUG
export LOGGING_LEVEL_ORG_SPRINGFRAMEWORK_WEB=TRACE

Here:

• logging.level.root → LOGGING_LEVEL_ROOT

• logging.level.org.springframework.web → LOGGING_LEVEL_ORG_SPRINGFRAMEWORK_WEB

This method is widely used in Docker and Kubernetes deployments.

Example: Changing Logging Levels in Docker

Imagine you have a Spring Boot app packaged into a Docker container. You can control logging without modifying the image:

FROM eclipse-temurin:17-jdk
COPY target/myapp.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Now, when running the container:

docker run -e LOGGING_LEVEL_ROOT=ERROR -e LOGGING_LEVEL_COM_MYAPP=DEBUG myapp:latest

This sets the root level to ERROR while keeping your custom package at DEBUG.

Example: Logging Levels in Kubernetes Deployment

In Kubernetes, environment variables are commonly set inside Deployment YAML files:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: springboot-app
spec:
  replicas: 2
  template:
    spec:
      containers:
      - name: springboot-container
        image: myregistry/springboot-app:latest
        env:
        - name: LOGGING_LEVEL_ROOT
          value: "INFO"
        - name: LOGGING_LEVEL_COM_MYAPP_SERVICE
          value: "DEBUG"

With this setup, you can adjust logs across multiple pods simply by updating the Deployment spec.

Spring Boot Actuator also allows runtime changes to log levels via its /actuator/loggers endpoint. Combined with environment variables, you can set a default log level at startup and adjust specific classes or packages dynamically.

Example request:

curl -X POST "http://localhost:8080/actuator/loggers/com.myapp.service" 
-H "Content-Type: application/json" 
-d '{"configuredLevel": "TRACE"}'

This avoids restarts altogether, which is critical for high-availability applications.

Best Practices for Managing Logging Levels

1. Use INFO in production: It provides enough detail without overwhelming log storage.

2. Enable DEBUG only when required: Debug logs can grow rapidly and increase costs in log aggregation systems.

3. Keep sensitive data out of logs: Always sanitize logs to avoid exposing passwords, tokens, or personal information.

4. Leverage profiles: Combine environment variables with Spring profiles (dev, test, prod) for consistent environments.

5. Centralize logs: Use ELK (Elasticsearch, Logstash, Kibana), Grafana Loki, or AWS CloudWatch for observability.

Common Pitfalls and How to Avoid Them

• Wrong variable format: Ensure you replace dots (.) with underscores (_) when setting environment variables.

• Case sensitivity: Environment variable names must be uppercase.

• Overlogging in production: Avoid leaving DEBUG or TRACE enabled in production—it can cause performance bottlenecks.

Final Thoughts

Configuring logging levels via environment variables in Spring Boot is more than just a convenience—it’s a best practice in today’s cloud-native development world. By externalizing log configuration, you make your application portable, secure, and adaptable across environments.

Whether you are running locally, inside Docker, or orchestrating containers in Kubernetes, using environment variables keeps your logging strategy consistent and flexible. Combined with runtime log management via Spring Boot Actuator, you gain complete visibility and control over your application’s behavior.

By following the approaches outlined in this article, you’ll ensure your Spring Boot projects remain easier to debug, monitor, and maintain—without sacrificing agility in modern deployments.