com.squareup.leakcanary

Class AnalysisResult

java.lang.Object

com.squareup.leakcanary.AnalysisResult

All Implemented Interfaces:

java.io.Serializable

public final class AnalysisResult
extends java.lang.Object
implements java.io.Serializable

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
long	analysisDurationMs Total time spent analyzing the heap.
java.lang.String	className Class name of the object that leaked if leakFound is true, null otherwise.
boolean	excludedLeak True if leakFound is true and the only path to the leaking reference is through excluded references.
java.lang.Throwable	failure Null unless the analysis failed.
boolean	leakFound True if a leak was found in the heap dump.
LeakTrace	leakTrace Shortest path to GC roots for the leaking object if leakFound is true, null otherwise.
static long	RETAINED_HEAP_SKIPPED
long	retainedHeapSize The number of bytes which would be freed if all references to the leaking object were released.

Method Summary

Modifier and Type	Method and Description
static AnalysisResult	failure(java.lang.Throwable failure, long analysisDurationMs)
static AnalysisResult	leakDetected(boolean excludedLeak, java.lang.String className, LeakTrace leakTrace, long retainedHeapSize, long analysisDurationMs)
java.lang.RuntimeException	leakTraceAsFakeException() Creates a new RuntimeException with a fake stack trace that maps the leak trace.
static AnalysisResult	noLeak(long analysisDurationMs)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

RETAINED_HEAP_SKIPPED

public static final long RETAINED_HEAP_SKIPPED

See Also:

Constant Field Values

leakFound

public final boolean leakFound

True if a leak was found in the heap dump.

excludedLeak

public final boolean excludedLeak

True if leakFound is true and the only path to the leaking reference is through excluded references. Usually, that means you can safely ignore this report.

className

@Nullable
public final java.lang.String className

Class name of the object that leaked if leakFound is true, null otherwise. The class name format is the same as what would be returned by Class.getName().

leakTrace

@Nullable
public final LeakTrace leakTrace

Shortest path to GC roots for the leaking object if leakFound is true, null otherwise. This can be used as a unique signature for the leak.

failure

@Nullable
public final java.lang.Throwable failure

Null unless the analysis failed.

retainedHeapSize

public final long retainedHeapSize

The number of bytes which would be freed if all references to the leaking object were released. RETAINED_HEAP_SKIPPED if the retained heap size was not computed. 0 if leakFound is false.

analysisDurationMs

public final long analysisDurationMs

Total time spent analyzing the heap.

Method Detail

noLeak

@NonNull
public static AnalysisResult noLeak(long analysisDurationMs)

leakDetected

@NonNull
public static AnalysisResult leakDetected(boolean excludedLeak,
                                                   @NonNull
                                                   java.lang.String className,
                                                   @NonNull
                                                   LeakTrace leakTrace,
                                                   long retainedHeapSize,
                                                   long analysisDurationMs)

failure

@NonNull
public static AnalysisResult failure(@NonNull
                                              java.lang.Throwable failure,
                                              long analysisDurationMs)

leakTraceAsFakeException

@NonNull
public java.lang.RuntimeException leakTraceAsFakeException()

Creates a new RuntimeException with a fake stack trace that maps the leak trace.

Leak traces uniquely identify memory leaks, much like stack traces uniquely identify exceptions.

This method enables you to upload leak traces as stack traces to your preferred exception reporting tool and benefit from the grouping and counting these tools provide out of the box. This also means you can track all leaks instead of relying on individuals reporting them when they happen.

The following example leak trace:

 * com.foo.WibbleActivity has leaked:
 * GC ROOT static com.foo.Bar.qux
 * references com.foo.Quz.context
 * leaks com.foo.WibbleActivity instance
 

Will turn into an exception with the following stacktrace:

 java.lang.RuntimeException: com.foo.WibbleActivity leak from com.foo.Bar (holder=CLASS,
 type=STATIC_FIELD)
         at com.foo.Bar.qux(Bar.java:42)
         at com.foo.Quz.context(Quz.java:42)
         at com.foo.WibbleActivity.leaking(WibbleActivity.java:42)