table of content

Part 1 Revisiting the foundation for code investigation

1 Starting to know your apps

1.1 How to more easily understand your app

1.2 Typical scenarios for using investigation techniques

1.2.1 Demystifying the unexpected output

1.2.2 Getting familiar with your external libraries

1.2.3 Clarifying slowness

1.2.4 Understanding app crashes

1.3 AI as a game changer in troubleshooting apps

1.4 What you will learn in this book

2 Understanding your app’s logic through debugging techniques

2.1 When analyzing code is not enough

2.2 Investigating code with a debugger

2.2.1 What is the execution stack trace, and how do I use it?

2.2.2 Navigating code with the debugger

2.3 When using the debugger might not be enough

3 Finding problem root causes using advanced debugging techniques

3.1 Minimizing investigation time with conditional breakpoints

3.2 Using breakpoints that don’t pause the execution

3.3 Dynamically altering the investigation scenario

3.4 Rewinding the investigation case

4 Making the most of logs: Auditing an app’s behavior

4.1 Investigating issues with logs

4.1.1 Using logs to identify exceptions

4.1.2 Using exception stack traces to identify what calls a method

4.1.3 Measuring time spent to execute a given instruction

4.1.4 Investigating problems in multithreaded architectures

4.2 Implementing logging

4.2.1 Persisting logs

4.2.2 Defining logging levels and using logging frameworks

4.2.3 Problems caused by logging and how to avoid them

Part 2 Deep diagnosing an app’s execution

5 Identifying resource consumption problems using profiling techniques

5.1 Where would a profiler be useful?

5.1.1 Identifying abnormal usage of resources

5.1.2 Finding out what code executes

5.1.3 Identifying slowness in an app’s execution

5.2 Using a profiler

5.2.1 Installing and configuring VisualVM

5.2.2 Observing the CPU and memory usage

5.2.3 Identifying memory leaks

5.3 Using AI assistance

6 Finding hidden problems using profiling techniques

6.1 Sampling to observe executing code

6.2 Profiling to learn how many times a method is executed

6.3 Using a profiler to identify SQL queries an app executes

6.3.1 Using a profiler to retrieve SQL queries not generated by a framework

6.3.2 Using the profiler to get the SQL queries generated by a framework

6.3.3 Using the profiler to get programmatically generated SQL queries

7 Investigating locks in multithreaded architectures

7.1 Monitoring threads for locks

7.2 Analyzing thread locks

7.3 Analyzing waiting threads

8 Investigating deadlocks with thread dumps

8.1 Getting a thread dump

8.1.1 Getting a thread dump using a profiler

8.1.2 Generating a thread dump from the command line

8.2 Reading thread dumps

8.2.1 Reading plain-text thread dumps

8.2.2 Using tools to better grasp thread dumps

Part 3 Diagnosing memory-related problems

9 Profiling memory-related problems

9.1 Sampling to identify memory allocation problems

9.2 Profiling to find the culprit

10 Investigating memory problems with heap dumps

10.1 Obtaining a heap dump

10.1.1 Configuring an app to generate a heap dump when it encounters a memory problem

10.1.2 Obtaining a heap dump using a profiler

10.1.3 Obtaining a heap dump with the command line

10.2 Reading a heap dump

10.3 Using the OQL console to query a heap dump

11 Analyzing potential JVM problems with GC logs

11.1 Enabling GC logs

11.2 Storing GC logs in files

11.3 Particular configurations for storing GC logs

11.4 Analyzing GC logs

11.4.1 Troubleshooting performance lags with GC pause times

11.4.2 Identifying memory leaks with heap usage logs

11.4.3 Identifying insufficient memory with full GC events

11.4.4 Tuning parallelism in GC

Part 4 Finding problems in large systems

12 Uncovering system-level failures and service communication problems

12.1 Troubleshooting communication patterns: RPC and messaging

12.1.1 Working with trace IDs and spans

12.1.2 OpenTelemetry, Jaeger, Zipkin, and other utilities

12.2 Serialization mismatches and versioning problems

12.3 Understanding systemic failure modes

12.3.1 Cascading failures

12.3.2 Retry storms

12.3.3 Timeout mismatches

13 Measuring data consistency and transactions

13.1 Troubleshooting inconsistencies across services

13.1.1 Inspecting time-based anomalies in event flows

13.1.2 Applying domain invariants to identify invalid states

13.2 Tracking and correlating multistep transactions

13.2.1 Reviewing audit logs to reconstruct transaction steps

13.2.2 Replaying events or examining event logs for missing messages

13.3 Measuring and monitoring consistency guarantees

13.3.1 Verifying data integrity using checksums or hashes

13.4 Running reconciliation jobs to compare expected vs. actual state

Appendices

Appendix A: Tools you’ll need

Appendix B: Opening a project

Appendix C: Recommended further reading

Appendix D: Understanding Java threads

D.1 What is a thread?

D.2 A thread’s life cycle

D.3 Synchronizing threads

D.3.1 Synchronized blocks

D.3.2 Using wait(), notify(), and notifyAll()

D.3.3 Joining threads

D.3.4 Blocking threads for a defined time

D.3.5 Synchronizing threads with blocking objects

D.4 Common problems in multithreaded architectures

D.4.1 Race conditions

D.4.2 Deadlocks

D.4.3 Livelocks

D.4.4 Starvation

D.5 Further reading

Appendix E: Memory management in Java apps

E.1 How the JVM organizes an app’s memory

E.2 The stack used by threads to store local data

E.3 The heap the app uses to store object instances

E.4 The metaspace memory location for storing data types

Appendix F: references

Overview

Appendix A. Tools you’ll need

This appendix outlines the essential tooling needed to follow the book’s examples and troubleshooting workflows. It highlights the core development stack, runtime requirements, and a set of diagnostic and monitoring utilities that support performance analysis, debugging, and observability throughout the chapters.

To work with the sample projects, you’ll need a Java IDE and a recent Java runtime. The appendix suggests popular IDE options—such as IntelliJ IDEA, Eclipse, or Apache NetBeans—and emphasizes installing JDK 17 or later, with a recommendation to use an OpenJDK distribution. With these in place, you can open, build, and run the provided projects consistently across environments.

For analysis and troubleshooting, the appendix recommends a layered toolset. VisualVM is used for profiling and for inspecting heap and thread dumps, while JProfiler is introduced for more advanced scenarios. Additional utilities include fastThread for deeper thread dump investigation, Postman for exercising HTTP endpoints during demonstrations, and Sentry for monitoring and analyzing log events in later chapters.

FAQ

Where can I find installation instructions for the tools used in the book?

The appendix provides links to installation instructions for all the recommended tools used in the examples.

Which IDEs can I use to open and execute the projects?

You can use IntelliJ IDEA (https://www.jetbrains.com/idea/download/), Eclipse IDE (https://www.eclipse.org/downloads/), or Apache NetBeans (https://netbeans.apache.org/download/index.html).

What Java version do I need to run the projects?

Install JDK version 17 or higher.

Which JDK distribution is recommended, and where do I download it?

The book recommends OpenJDK; you can get it at https://jdk.java.net/17/.

What tool is used for profiling and reading heap and thread dumps?

VisualVM is used for profiling and for reading heap dumps and thread dumps: https://visualvm.github.io/download.html.

What do I use when VisualVM isn’t enough for certain techniques?

For those cases, the book uses JProfiler: https://www.ej-technologies.com/jprofiler.

How does the book investigate thread dumps in chapter 9?

It uses fastThread: https://fastthread.io/.

What tool is used to call endpoints during the examples?

Postman is used throughout the book: https://www.postman.com/downloads/.

How are log events monitored in the book?

Chapter 12 discusses monitoring log events with Sentry: https://sentry.io.

Do I need both VisualVM and JProfiler to follow the profiling content?

The book uses VisualVM for many tasks and JProfiler for techniques where VisualVM isn’t enough, so you’ll use both to follow all the examples.

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more

eBook

pdf, ePub, online

$54.99 $27.49

you save $27.50 (50%)

include audio $24.99 $12.49

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more

eBook

$54.99 $27.49

you save $27.50 (50%)

include audio $24.99 $12.49

eBook

pdf, ePub, online

$54.99 $27.49

you save $27.50 (50%)

include audio $24.99 $12.49

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more