liveBookmanning.com

What you will learn in Troubleshooting Java, Second Edition

by Laurențiu Spilcă
Foreword by Ben Evans

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• monitoringLogging is the technique of recording runtime events and diagnostic information from an application or virtual machine.
• profilerA profiler is a software tool that measures and records runtime behavior such as execution time, resource usage, and call activity.
• profilingProfiling is the measurement or recording of program execution to identify which code runs and how resources are used.
• debuggerA debugger is a software tool that pauses program execution and allows code to be run step by step while observing state changes.
• thread dumpA thread dump is a snapshot of the states and stack information of an application's threads at a particular moment.
• VisualVMVisualVM is a free Java monitoring and profiling tool that provides runtime information about applications and the JVM.
• stack traceA stack trace is a diagnostic record showing the sequence of active function or method calls at a particular execution point, typically including source locations.
• heap dumpA heap dump is a diagnostic snapshot of the objects, values, and references present in a Java heap at a particular time.
• debuggingA software investigation technique for finding and solving problems in code, including analyzing how implemented logic works.
• spanA span is a recorded unit of work within a distributed trace, including its operation, timing, service, and associated metadata.
• code analysisA method for examining source code and its execution to understand behavior, identify problems, or support changes.
• breakpointA breakpoint is a marker in program code that causes a debugger to pause execution when that location is reached.
• monitorA monitor object is an object whose intrinsic synchronization monitor coordinates exclusive access among threads.
• conditional breakpointA conditional breakpoint is a debugger breakpoint that pauses execution only when its associated Boolean condition evaluates to true.
• garbage collectionGarbage collection is the automatic runtime process of reclaiming memory occupied by objects that are no longer reachable.
• logging levelA logging level is a configuration category that controls the severity or amount of messages emitted or stored by a logging system.
• GC pausePause time is the duration for which application execution is suspended or constrained during a runtime operation such as garbage collection.
• deadlockA deadlock is a concurrency failure in which threads or transactions wait indefinitely for locks or resources held by one another.
• memory leakA memory leak is a software defect in which allocated memory remains unreleased after it is no longer needed.
• synchronizedA synchronized block is a Java language construct that acquires an object's monitor while executing a guarded section of code.
• memory usageMemory usage is the amount of runtime memory occupied or allocated by a process or its components.
• SQLAn SQL query is a statement expressed in Structured Query Language that requests or modifies data in a database system.
• Object Query LanguageObject Query Language is a query language for retrieving and examining objects and related data in heap dumps.
• postmortemA postmortem investigation is troubleshooting performed after an application has crashed and stopped running.
• G1 GCG1 GC is a region-based Java garbage collector that divides the heap into regions and prioritizes collection of regions with the most reclaimable space.
• synchronizationThread synchronization is the coordination of concurrent threads to control their access to shared state and operations.
• instrumentationInstrumentation is the insertion or activation of runtime measurement code to record program execution behavior.
• timeout mismatchA timeout mismatch is an incompatibility between timeout settings in communicating components that causes communication failures under load or delay.
• JaegerJaeger is an open-source distributed tracing platform for collecting, storing, and visualizing traces across services.
• hash functionHashing is the transformation of data into a fixed-size digest that can be compared to detect content differences without transmitting the original data.
• trace treeA trace tree is a hierarchical representation of a trace in which parent and child spans show the structure of a request's operations.
• log rotationFile rotation is a logging technique that distributes successive log data across bounded files and replaces or archives older files.
• zombie threadA zombie thread is a thread that remains open and executes without purposeful work, potentially causing performance and memory problems.
• retry stormA retry storm is a systemic overload condition in which many services repeatedly retry failed requests and thereby amplify traffic and load.
• SentrySentry is a real-time error monitoring platform that collects and organizes application exceptions, stack traces, and runtime error context.
• EdenEden is the young-generation heap region where newly allocated Java objects initially reside.
• old generationThe old generation is the heap region that contains objects that have survived enough collection cycles to be promoted from younger regions.
• survivor regionA survivor region is a young-generation heap region that holds objects which remain reachable after young-generation garbage collections.
• starvationA concurrency condition in which a thread is unfairly excluded from obtaining execution time or a required resource.
• CPU timeCPU time is the amount of processor time a method or operation actively spends executing instructions.
• dynamic proxyA dynamic proxy is a runtime-generated object that implements specified interfaces and delegates method calls to an invocation handler.
• full GC cycleFull garbage collection is a garbage-collection cycle that examines and reclaims objects across the heap rather than only a young-generation region.
• GC eventA GC event is a recorded garbage-collection operation with a type, phases, timing information, and changes to heap regions or objects.
• young generationThe young generation is the heap area containing newly allocated and relatively short-lived objects.
• cascading failureA cascading failure is a systemic failure in which one overloaded or failing service causes dependent or upstream services to degrade or fail in succession.
• referenceAn object reference is a value that identifies an object and can keep that object reachable for memory-management purposes.
• gRPCgRPC is a remote procedure call framework and protocol for invoking operations across services, commonly using HTTP/2 and Protocol Buffers.
• cascading blocked threadA cascading blocked thread is a thread whose waiting for an external event causes other threads to wait in sequence rather than forming a circular deadlock.
• complex deadlockA complex deadlock is a deadlock involving a chain of more than two threads in which each thread blocks another.
• observabilityObservability is the ability to infer a system's internal behavior from its emitted telemetry and other external outputs.
• -Xmx-Xmx is a JVM startup property that sets the maximum heap size available to a Java application.
• ArrayListArrayList is Java's resizable-array implementation of the List collection abstraction.
• race conditionA race condition is a concurrency defect whose outcome depends on the timing or interleaving of operations.
• checksumA checksum is a computed value derived from data for detecting changes or transmission and storage errors.
• data integrityData integrity is the property that data remains accurate, consistent, complete, and trustworthy throughout its life cycle and across system boundaries.
• lock monitoringLock monitoring is the observation of thread blocking, lock ownership, and lock-holding duration during program execution.
• ZipkinZipkin is an open-source distributed tracing system for collecting and visualizing timing data for requests across services.
• serialization mismatchA serialization mismatch is an incompatibility between the data representation produced by one component and the representation expected by another.
• stubA stub is a controllable fake application or component that substitutes for a real dependency during investigation or testing.
• serializationSerialization is the process of transforming structured in-memory data into a transferable or storable byte representation.
• Apache KafkaKafka is a distributed event-streaming platform that publishes, stores, and delivers records through topics.
• Kafka topicA Kafka topic is a named stream in Kafka to which producers publish records and from which consumers read them.
• time-based anomalyA time-based anomaly is an irregularity in the timing, ordering, or temporal correlation of events relative to expected system behavior.
• percentileP95 latency is the response-time value at or below which 95 percent of measured requests complete.
• drop frameA debugger operation that returns execution to an earlier point in the call stack and re-runs a method from that point.
• artificial intelligenceArtificial intelligence is the field of computing concerned with systems that perform tasks requiring capabilities associated with human intelligence.
• ChatGPTChatGPT is a conversational AI system that generates natural-language responses to user prompts.
• hallucinationAn AI hallucination is an AI-generated claim or detail that appears plausible but is fabricated or unsupported by reality.
• heisenbugA Heisenbug is a software behavior or failure that changes when the program is observed or interfered with, especially through debugging.
• runtime variable modificationRuntime data modification is changing program data while execution is paused to examine behavior under a custom state.
• appenderAn appender is a logging component that writes log messages to a configured destination.
• FormatterA formatter is a logging component that determines the textual structure of log messages.
• Log4jLog4j is a Java logging framework that provides APIs and configuration for recording, formatting, and routing log messages.
• Log4j XML configurationA Log4j XML configuration is an XML document that specifies Log4j loggers, appenders, formatters, and related settings.
• LoggerA logger is a Log4j component or object that accepts application messages at specified severity levels.
• logging configurationLogging configuration is a set of settings that determines which messages are recorded and how and where they are written.
• Step IntoStep into is a debugger navigation operation that enters a method called by the current execution line.
• Step OutStep out is a debugger navigation operation that resumes debugger execution until it returns from the current scope to the previous one.
• Step OverStep over is a debugger navigation operation that executes the next execution line without entering a method called from the current line.
• crashAn app crash is an application failure in which the application terminates or remains running but stops responding to requests.
• maintainabilityA maintainability problem is a condition in which software is harder to understand, modify, or support because of its structure or implementation.
• -Xms-Xms is a JVM startup property that sets the initial heap size available to a Java application.
• severitySeverity is a classification of how seriously an application event or condition affects operation.
• thread pool exhaustionThread pool exhaustion is a condition in which all available worker threads are occupied, preventing additional tasks from executing.
• backward compatibilityBackward compatibility is the ability of a newer consumer or implementation to process data produced according to an older schema.
• data contractA data contract is an agreed schema and interpretation for data exchanged between software components or services.
• deserializationDeserialization is the process of reconstructing structured data from a serialized byte representation.
• forward compatibilityForward compatibility is the ability of an older consumer or implementation to tolerate data produced according to a newer schema.
• schema mismatchA schema mismatch is an incompatibility between the data structure expected by one service and the structure supplied by another.
• schema validationSchema validation is the process of checking data or schema definitions against declared structural and compatibility rules.
• locked threadA locked thread is a thread prevented from entering or executing a synchronized region because another thread holds the relevant monitor.
• notifyAll methodThe Java Object.notifyAll method awakens all threads waiting on the object's monitor so they can compete to reacquire it.
• waitThe Java Object.wait method releases the object's monitor and suspends the calling thread until notification or interruption occurs.
• wait/notify approachA wait/notify approach coordinates threads by suspending them with wait and resuming eligible waiting threads with notification.
• waiting threadA waiting thread is a thread that has voluntarily paused execution until a monitor notifies it to continue.
• cognitive complexityThe mental difficulty of understanding code investigation as the number of nested reasoning paths and open investigative plans increases.
• JPQLJPQL is an object-oriented query language for retrieving and manipulating persistent entities defined by the Java Persistence API.
• N + 1 query problemThe N + 1 query problem is an access pattern in which one initial query is followed by a separate query for each of N retrieved records.
• Spring Data JPASpring Data JPA is a Spring-based library that provides repository abstractions for accessing relational data through Java Persistence API implementations.
• metaspaceMetaspace is JVM-managed native memory that stores class metadata needed during Java application execution.
• blast radiusBlast radius is the scope of components, records, or systems affected by a failure or data problem.
• consumer groupA consumer group is a set of consumers that cooperatively processes the same Kafka topic stream.
• eventAn event is a message representing something that has already happened in a system.
• event replayEvent replay is the technique of feeding previously recorded event messages back into a system to reproduce workflows or behavior.
• kafka-console-consumerkafka-console-consumer is a Kafka command-line tool that reads and displays records from Kafka topics.
• kafka-console-producerkafka-console-producer is a Kafka command-line utility for publishing records to Kafka topics.
• time zoneA time zone is a rule set that determines the local time offset and related date-time conventions for a geographic or system context.
• OpenTelemetryOpenTelemetry is an open-source observability framework and standard for collecting, generating, and exporting telemetry such as traces, metrics, and logs.
• OpenTelemetry Java agentThe OpenTelemetry Java agent is a Java agent that automatically instruments supported application frameworks and libraries to capture telemetry.
• JVM optionA JVM option is a configuration argument supplied to the Java Virtual Machine to control its runtime behavior.
• method invocationA method invocation is an execution-time call to a method, including each occurrence of entering that method.
• Java recordA Java record is a Java class-like language feature for declaring data-oriented types with implicitly final components and generated data-access methods.
• staging environmentA staging environment is a pre-production environment used to validate application behavior under conditions resembling production.
• joinAn SQL JOIN is a relational query operation that combines rows from multiple tables according to a matching condition.
• fastThreadfastThread is a web-based tool that analyzes thread dumps and presents their contents through visualizations and diagnostic details.
• root causeThe underlying reason a software behavior or failure occurs.
• -XX:ConcGCThreads-XX:ConcGCThreads is a JVM option that sets the number of threads used for concurrent background garbage-collection work.
• -XX:ParallelGCThreads-XX:ParallelGCThreads is a JVM option that sets the number of threads used for parallel garbage-collection work during stop-the-world phases.
• memory pressureMemory pressure is a condition in which available runtime memory is insufficient relative to an application's allocation and retention demands.
• referrerA referrer is an object or runtime entity that holds a reference to another object.
• illegal stateAn invalid state is a condition represented in system data that violates domain rules or does not make sense in the real world.
• next execution lineThe next execution line is the line of source code that an application will execute next, which may differ from the immediately following line because of control flow or exceptions.
• stop-the-world eventA stop-the-world phase is a garbage-collection phase during which application threads are paused.
• non-blocking breakpointA non-blocking breakpoint is a breakpoint configuration that records messages or values when reached without pausing program execution.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.