Package-level declarations
Types
Creates ReferenceReader instances that will follow references from all HeapObjects, applying matching rules provided by referenceMatchers, and not creating any virtual reference.
Creates ReferenceReader instances that will follow references from all HeapObjects, applying matching rules provided by referenceMatchers, creating additional virtual instance reference based on known Android classes.
Defines VirtualInstanceReferenceReader factories for common Apache Harmony data structures.
A leak found by HeapAnalyzer in your application.
Inspector that automatically marks instances of the provided class names as not leaking because they're app wide singletons.
A ReferenceReader that first delegates expanding to virtualRefReaders in order until one matches (or none), and then always proceeds with fieldRefReader. This means any synthetic ref will be on the shortest path, but we still explore the entire data structure so that we correctly track which objects have been visited and correctly compute dominators and retained size.
Expands instance fields that hold non null references.
Finds the objects that are leaking by scanning all objects in the heap dump and delegating the decision to a list of FilteringLeakingObjectFinder.LeakingObjectFilter
FlatteningPartitionedInstanceReferenceReader provides a synthetic and stable representation of a data structure that maps how we think about that data structure instead of how it is internally implemented. You can think of it as surfacing additional direct references to entries that the data structure holds. VirtualInstanceReferenceReader implementations scan references based on known patterns rather than through generic traversals. As a result, they do not surface references and objects that are part of the data structure implementations, such as internal arrays or linked lists. This is a problem because the same traversal is also used to compute retained size, so we need to accounts for all reachable objects.
The result of an analysis performed by HeapAnalyzer, either a HeapAnalysisSuccess or a HeapAnalysisFailure. This class is serializable however there are no guarantees of forward compatibility.
The analysis performed by HeapAnalyzer did not complete successfully.
The result of a successful heap analysis performed by HeapAnalyzer.
Analyzes heap dumps to look for leaks.
IgnoredReferenceMatcher should be used to match references that cannot ever create leaks. The shortest path finder will never go through matching references.
Finds all objects tracked by a KeyedWeakReference, ie all objects that were passed to ObjectWatcher.watch.
A leak found by HeapAnalyzer, either an ApplicationLeak or a LibraryLeak.
Finds the objects that are leaking, for which Shark will compute leak traces.
The best strong reference path from a GC root to the leaking object. "Best" here means the shortest prioritized path. A large number of distinct paths can generally be found leading to a leaking object. Shark prioritizes paths that don't go through known LibraryLeakReferenceMatcher (because those are known to create leaks so it's more interesting to find other paths causing leaks), then it prioritize paths that don't go through java local gc roots (because those are harder to reason about). Taking those priorities into account, finding the shortest path means there are less LeakTraceReference that can be suspected to cause the leak.
A LeakTraceReference represents an origin LeakTraceObject and either a reference from that object to the LeakTraceObject in the next LeakTraceReference in LeakTrace.referencePath, or to LeakTrace.leakingObject if this is the last LeakTraceReference in LeakTrace.referencePath.
A leak found by HeapAnalyzer, where the only path to the leaking object required going through a reference matched by pattern, as provided to a LibraryLeakReferenceMatcher instance. This is a known leak in library code that is beyond your control.
LibraryLeakReferenceMatcher should be used to match references in library code that are known to create leaks and are beyond your control. The shortest path finder will only go through matching references after it has exhausted references that don't match, prioritizing finding an application leak over a known library leak. Library leaks will be reported as LibraryLeak instead of ApplicationLeak.
TODO Extracted from PathFinder, this should eventually be part of public API surface and we should likely also revisit the gc root type filtering which happens during heap parsing, as that's not really a concern for the heap parser and more for path finding. There are probably memory concerns as well there though. We could:
Extracts metadata from a hprof to be reported in HeapAnalysisSuccess.metadata.
Exposes high level APIs to compute and render a dominator tree. This class needs to be public to be used by other LeakCanary modules but is internal and its API might change at any moment.
Looks for objects that have grown in outgoing references in a new heap dump compared to a previous heap dump by diffing heap traversals.
Provides LeakCanary with insights about objects (classes, instances and arrays) found in the heap. inspect will be called for each object that LeakCanary wants to know more about. The implementation can then use the provided ObjectReporter to provide insights for that object.
A set of default ObjectInspectors that knows about common JDK objects.
Enables ObjectInspector implementations to provide insights on heapObject, which is an object (class, instance or array) found in the heap.
Reports progress from the HeapAnalyzer as they occur, as Step values.
Defines VirtualInstanceReferenceReader factories for common OpenJDK data structures.
Not thread safe.
TODO This is quite similar to the leaktrace equivalent
Used to pattern match known patterns of references in the heap, either to ignore them (IgnoredReferenceMatcher) or to mark them as library leaks (LibraryLeakReferenceMatcher), which lowers their traversal priority when exploring the heap.
A pattern that will match references for a given ReferenceMatcher.
Creates ReferenceReader instances that will follow references from all HeapObjects, applying matching rules provided by referenceMatchers, creating additional virtual instance reference based on the list of VirtualInstanceReferenceReader created by virtualRefReadersFactory.