From the documentation at https://docs.spring.io/spring-boot/reference/features/logging.html#features.logging.console-output :

you can also specify debug=true in your application.properties.

When the debug mode is enabled, a selection of core loggers (embedded container, Hibernate, and Spring Boot) are configured to output more information.

When you set debug=true a bunch of "core" loggers used under the hood by spring boot will be set to debug: web container (like a tomcat), spring boot itself, hibernate.

It won't affect the loggers of your application though - they'll still be at INFO severity level.

However, if you set something like logging.level.root=debug probably all the loggers will be set to DEBUG, so yes, technically there is a difference.

From the spring boot documentation:

When the debug mode is enabled, a selection of core loggers (embedded container, Hibernate, and Spring Boot) are configured to output more information. Enabling the debug mode does not configure your application to log all messages with DEBUG level.

1. Enable Spring Boot's debugging by adding debug=true to your application.properties file.

   This creates log output during startup. For each auto-configuration available it contains the information if it "matched" or not, i.e. if it's preconditions are fulfilled, and what these conditions are.

2. Look especially in the section Negative matches of the output for auto-configurations that should happen but don't. Searching for relevant technologies in the log is a good idea.

3. auto-configurations you found in the previous step might hint at other auto-configurations that didn't get activated. For these repeat step 2.

The following is an example of that search for https://github.com/iosenberg/todo/commit/c4cfbf63132e251ce98cfe02178bd48cc447aac7 Which was referenced in Spring boot can't find Repository bean

The missing bean is a Spring Data JDBC repository. Therefore datasource or jdbc come to mind as first search terms. Searching for JDBC yields the following results that seem relevant:

   DataSourceAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'javax.sql.DataSource', 'org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType' (OnClassCondition)
      - @ConditionalOnMissingBean (types: io.r2dbc.spi.ConnectionFactory; SearchStrategy: all) did not find any beans (OnBeanCondition)

   DataSourceTransactionManagerAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'org.springframework.jdbc.core.JdbcTemplate', 'org.springframework.transaction.TransactionManager' (OnClassCondition)

This looks like there is a DataSource, which just demonstrates that you shouldn't stop at the first match.

The next match is:

   DataSourceInitializationConfiguration:
      Did not match:
         - @ConditionalOnSingleCandidate (types: javax.sql.DataSource; SearchStrategy: all) did not find any beans (OnBeanCondition)
      Matched:
         - @ConditionalOnClass found required class 'org.springframework.jdbc.datasource.init.DatabasePopulator' (OnClassCondition)

So, DataSourceAutoConfiguration did run, but we still don't seem to have a DataSource bean. From this we learn that there is an important difference between a class being available and a bean of that type being available. Kind of obvious when you say it out loud, yet easy to miss when you look at some log file.

The rest of the search turns up just more stuff that doesn't work, which is either irrelevant, or not surprising if there is no DataSource bean. Therefore I switched to searching for datasource in the log.

That returns tons of hits. But the first one in the Negative matches was really helpful.

   DataSourceAutoConfiguration.EmbeddedDatabaseConfiguration:
      Did not match:
         - EmbeddedDataSource did not find embedded database (DataSourceAutoConfiguration.EmbeddedDatabaseCondition)

So no embedded database found! What database is it trying to use? Checking the application.properties for a JDBC url shows there is none. Checking the dependencies shows there is an embedded database, but only with scope test, therefore for the main program there is no JDBC driver available. Fixing that by making the in memory database dependency available for the main application solved the proble.

Adding debug=true to the application.properties or debug: true in the application.yml, file should help. You'll get more detailed logging.

Generally, if you want to see more fine-grained log messages from all members of a given package, you can set that by adding a line such as:

logging.level.<package_name>=<LOGGING_LEVEL>

for example:

logging.level.org.springframework.context=DEBUG

These log messages may be helpful in finding the core of the problem (in this case why a given exception was thrown).