;
; Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
; DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
;
; This code is free software; you can redistribute it and/or modify it
; under the terms of the GNU General Public License version 2 only, as
; published by the Free Software Foundation.  Oracle designates this
; particular file as subject to the "Classpath" exception as provided
; by Oracle in the LICENSE file that accompanied this code.
;
; This code is distributed in the hope that it will be useful, but WITHOUT
; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
; version 2 for more details (a copy is included in the LICENSE file that
; accompanied this code).
;
; You should have received a copy of the GNU General Public License version
; 2 along with this work; if not, write to the Free Software Foundation,
; Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
;
; Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
; or visit www.oracle.com if you need additional information or have any
; questions.
;

[environment.active-recordings]
label = "Active Recordings"
table = "COLUMN 'Start', 'Duration', 'Name',
                'Destination', 'Max Age', 'Max Size'
         FORMAT none, none, none,
                cell-height:5, none, none
         SELECT LAST(recordingStart), LAST(recordingDuration), LAST(name),
                LAST(destination), LAST(maxAge), LAST(maxSize)
         FROM ActiveRecording
         GROUP BY id"

[environment.active-settings]
label = "Active Settings"
table = "COLUMN 'Event Type', 'Enabled', 'Threshold',
                'Stack Trace','Period','Cutoff', 'Throttle'
         FORMAT none, missing:whitespace, missing:whitespace, missing:whitespace,
                missing:whitespace, missing:whitespace, missing:whitespace,
                missing:whitespace
         SELECT E.id, LAST_BATCH(E.value), LAST_BATCH(T.value),
                LAST_BATCH(S.value), LAST_BATCH(P.value),
                LAST_BATCH(C.value), LAST_BATCH(U.value)
         FROM
                ActiveSetting AS E,
                ActiveSetting AS T,
                ActiveSetting AS S,
                ActiveSetting AS P,
                ActiveSetting AS C,
                ActiveSetting AS U
         WHERE
               E.name = 'enabled' AND
               T.name = 'threshold' AND
               S.name = 'stackTrace' AND
               P.name = 'period' AND
               C.name = 'cutoff' AND
               U.name = 'throttle'
         GROUP BY
                 id
         ORDER BY
                 E.id"

[application.allocation-by-class]
label = "Allocation by Class"
table = "COLUMN 'Object Type', 'Allocation Pressure'
         FORMAT none, normalized
         SELECT objectClass AS O, SUM(weight) AS W
         FROM ObjectAllocationSample GROUP BY O ORDER BY W DESC LIMIT 25"

[application.allocation-by-thread]
label = "Allocation by Thread"
table = "COLUMN 'Thread', 'Allocation Pressure'
         FORMAT none, normalized
         SELECT eventThread AS T, SUM(weight) AS W
         FROM ObjectAllocationSample GROUP BY T ORDER BY W DESC LIMIT 25"

[application.allocation-by-site]
label = "Allocation by Site"
table = "COLUMN 'Method', 'Allocation Pressure'
         FORMAT none, normalized
         SELECT stackTrace.topFrame AS S, SUM(weight) AS W
         FROM ObjectAllocationSample
         GROUP BY S
         ORDER BY W DESC LIMIT 25"

[jvm.blocked-by-system-gc]
label = "Blocked by System.gc()"
table = "FORMAT none, none, cell-height:10
         SELECT startTime, duration, stackTrace
         FROM SystemGC
         WHERE invokedConcurrent = 'false'
         ORDER BY duration DESC
         LIMIT 25"

[application.class-loaders]
label = "Class Loaders"
table = "FORMAT missing:null-bootstrap, none, none
         SELECT classLoader, LAST(hiddenClassCount),
         LAST(classCount) AS C
         FROM ClassLoaderStatistics
         GROUP BY classLoader ORDER BY C DESC";

[jvm.class-modifications]
label = "Class Modifications"
table = "COLUMN 'Time', 'Requested By', 'Operation', 'Classes'
         SELECT duration, stackTrace.topApplicationFrame, eventType.label, classCount
         FROM RetransformClasses, RedefineClasses
         GROUP BY redefinitionId
         ORDER BY duration DESC"

[jvm.compiler-configuration]
label = "Compiler Configuration"
form = "SELECT LAST(threadCount), LAST(dynamicCompilerThreadCount), LAST(tieredCompilation)
        FROM CompilerConfiguration"

[jvm.compiler-statistics]
label = "Compiler Statistics"
form = "SELECT LAST(compileCount), LAST(peakTimeSpent), LAST(totalTimeSpent),
               LAST(bailoutCount), LAST(osrCompileCount),
               LAST(standardCompileCount), LAST(osrBytesCompiled),
               LAST(standardBytesCompiled), LAST(nmethodsSize),
               LAST(nmethodCodeSize) FROM CompilerStatistics"

[jvm.compiler-phases]
label = "Concurrent Compiler Phases"
table = "COLUMN 'Level', 'Phase', 'Average',
                'P95', 'Longest', 'Count',
                'Total'
         SELECT phaseLevel AS L, phase AS P, AVG(duration),
                P95(duration),  MAX(duration), COUNT(*),
                SUM(duration) AS S
         FROM CompilerPhase
         GROUP BY P ORDER BY L ASC, S DESC"

[environment.container-configuration]
label = "Container Configuration"
form = "SELECT LAST(containerType), LAST(cpuSlicePeriod), LAST(cpuQuota), LAST(cpuShares),
               LAST(effectiveCpuCount), LAST(memorySoftLimit), LAST(memoryLimit),
               LAST(swapMemoryLimit), LAST(hostTotalMemory)
               FROM ContainerConfiguration"

[environment.container-cpu-usage]
label = "Container CPU Usage"
form = "SELECT LAST(cpuTime), LAST(cpuUserTime), LAST(cpuSystemTime) FROM ContainerCPUUsage"

[environment.container-memory-usage]
label = "Container Memory Usage"
form = "SELECT LAST(memoryFailCount), LAST(memoryUsage), LAST(swapMemoryUsage) FROM ContainerMemoryUsage"

[environment.container-io-usage]
label = "Container I/O Usage"
form = "SELECT LAST(serviceRequests), LAST(dataTransferred) FROM ContainerIOUsage"

[environment.container-cpu-throttling]
label = "Container CPU Throttling"
form = "SELECT LAST(cpuElapsedSlices), LAST(cpuThrottledSlices), LAST(cpuThrottledTime) FROM ContainerCPUThrottling"

[application.contention-by-thread]
label = "Contention by Thread"
table = "COLUMN 'Thread', 'Count', 'Avg', 'P90', 'Max.'
         SELECT eventThread, COUNT(*), AVG(duration), P90(duration), MAX(duration) AS M
         FROM JavaMonitorEnter GROUP BY eventThread ORDER BY M"

[application.contention-by-class]
label = "Contention by Lock Class"
table = "COLUMN 'Lock Class', 'Count', 'Avg.', 'P90', 'Max.'
         SELECT monitorClass, COUNT(*), AVG(duration), P90(duration), MAX(duration) AS M
         FROM JavaMonitorEnter GROUP BY monitorClass ORDER BY M"

[application.contention-by-site]
label = "Contention by Site"
table = "COLUMN 'StackTrace', 'Count', 'Avg.', 'Max.'
         SELECT stackTrace AS S, COUNT(*), AVG(duration), MAX(duration) AS M
         FROM JavaMonitorEnter GROUP BY S ORDER BY M"

[application.contention-by-address]
label = "Contention by Monitor Address"
table = "COLUMN 'Monitor Address', 'Class', 'Threads', 'Max Duration'
         SELECT address, FIRST(monitorClass), UNIQUE(eventThread), MAX(duration) AS M
         FROM JavaMonitorEnter
         GROUP BY monitorClass ORDER BY M"

[application.deprecated-methods-for-removal]
label = "Deprecated Methods for Removal"
table = "COLUMN 'Deprecated Method', 'Called from Class'
         FORMAT truncate-beginning, cell-height:10000;truncate-beginning
         SELECT method AS m, SET(stackTrace.topFrame.method.type)
         FROM DeprecatedInvocation
         WHERE forRemoval = 'true'
         GROUP BY m
         ORDER BY m"

[environment.cpu-information]
label ="CPU Information"
form = "SELECT cpu, sockets, cores, hwThreads, description FROM CPUInformation"

[environment.cpu-load]
label = "CPU Load Statistics"
form = "COLUMN
        'JVM User (Minimum)',
        'JVM User (Average)',
        'JVM User (Maximum)',
        'JVM System (Minimum)',
        'JVM System (Average)',
        'JVM System (Maximum)',
        'Machine Total (Minimum)',
        'Machine Total (Average)',
        'Machine Total (Maximum)'
        SELECT MIN(jvmUser), AVG(jvmUser), MAX(jvmUser),
               MIN(jvmSystem), AVG(jvmSystem), MAX(jvmSystem),
               MIN(machineTotal), AVG(machineTotal), MAX(machineTotal)
               FROM CPULoad"

[environment.cpu-load-samples]
label = "CPU Load"
table = "SELECT startTime, jvmUser, jvmSystem, machineTotal FROM CPULoad"

[environment.cpu-tsc]
label ="CPU Time Stamp Counter"
form = "SELECT LAST(fastTimeAutoEnabled), LAST(fastTimeEnabled),
               LAST(fastTimeFrequency), LAST(osFrequency)
        FROM CPUTimeStampCounter"

[jvm.deoptimizations-by-reason]
label = "Deoptimization by Reason"
table = "SELECT reason, COUNT(reason) AS C
         FROM Deoptimization GROUP BY reason ORDER BY C DESC"

[jvm.deoptimizations-by-site]
label = "Deoptimization by Site"
table = "SELECT method, lineNumber, bci, COUNT(reason) AS C
         FROM Deoptimization GROUP BY method ORDER BY C DESC"

[environment.events-by-count]
label = "Event Types by Count"
table = "SELECT eventType.label AS E, COUNT(*) AS C FROM * GROUP BY E ORDER BY C DESC"

[environment.events-by-name]
label = "Event Types by Name"
table = "SELECT eventType.label AS E, COUNT(*) AS C FROM * GROUP BY E ORDER BY E ASC"

[environment.environment-variables]
label = "Environment Variables"
table = "FORMAT none, cell-height:20
         SELECT LAST(key) AS K, LAST(value)
         FROM InitialEnvironmentVariable GROUP BY key ORDER BY K"

[application.exception-count]
label ="Exception Statistics"
form = "COLUMN 'Exceptions Thrown' SELECT DIFF(throwables) FROM ExceptionStatistics"

[application.exception-by-type]
label ="Exceptions by Type"
table = "COLUMN 'Class', 'Count'
         SELECT thrownClass AS T, COUNT(thrownClass) AS C
         FROM JavaErrorThrow, JavaExceptionThrow GROUP BY T ORDER BY C DESC"

[application.exception-by-message]
label ="Exceptions by Message"
table = "COLUMN 'Message', 'Count'
         SELECT message AS M, COUNT(message) AS C
         FROM JavaErrorThrow, JavaExceptionThrow GROUP BY M ORDER BY C DESC"

[application.exception-by-site]
label ="Exceptions by Site"
table = "COLUMN 'Method', 'Count'
         SELECT stackTrace.topNotInitFrame AS S, COUNT(startTime) AS C
         FROM JavaErrorThrow, JavaExceptionThrow GROUP BY S ORDER BY C DESC"

[application.file-reads-by-path]
label = "File Reads by Path"
table = "COLUMN 'Path', 'Reads', 'Total Read'
         FORMAT cell-height:5, none, none
         SELECT path, COUNT(*), SUM(bytesRead) AS S FROM FileRead
         GROUP BY path ORDER BY S DESC"

[application.file-writes-by-path]
label = "File Writes by Path"
table = "COLUMN 'Path', 'Writes', 'Total Written'
         FORMAT cell-height:5, none, none
         SELECT path, COUNT(bytesWritten), SUM(bytesWritten) AS S FROM FileWrite
         GROUP BY path ORDER BY S DESC"

[application.finalizers]
label = "Finalizers"
table = "SELECT finalizableClass, LAST_BATCH(objects) AS O, LAST_BATCH(totalFinalizersRun)
         FROM FinalizerStatistics GROUP BY finalizableClass ORDER BY O DESC"

[jvm.gc]
label = "Garbage Collections"
table = "COLUMN 'Start', 'GC ID', 'Type', 'Heap Before GC', 'Heap After GC', 'Longest Pause'
         FORMAT none, none, missing:Unknown, none, none, none
         SELECT G.startTime, gcId, [Y|O].eventType.label,
                B.heapUsed, A.heapUsed, longestPause
         FROM
                GarbageCollection AS G,
                GCHeapSummary AS B,
                GCHeapSummary AS A,
                OldGarbageCollection AS O,
                YoungGarbageCollection AS Y
         WHERE B.when = 'Before GC' AND A.when = 'After GC'
         GROUP BY gcId ORDER BY G.startTime"

[jvm.gc-concurrent-phases]
label = "Concurrent GC Phases"
table = "COLUMN 'Name', 'Average', 'P95',
                'Longest', 'Count', 'Total'
         SELECT name,  AVG(duration),  P95(duration),
                MAX(duration), COUNT(*), SUM(duration) AS S
         FROM   GCPhaseConcurrent, GCPhaseConcurrentLevel1
         GROUP BY name ORDER BY S"

[jvm.gc-parallel-phases]
label = "Parallel GC Phases"
table = "COLUMN 'Name', 'Average', 'P95',
                'Longest', 'Count', 'Total'
         SELECT name,  AVG(duration),  P95(duration),
                MAX(duration), COUNT(*), SUM(duration) AS S
         FROM   GCPhaseParallel
         GROUP BY name ORDER BY S"

[jvm.gc-configuration]
label = 'GC Configuration'
form = "COLUMN 'Young GC', 'Old GC',
               'Parallel GC Threads','Concurrent GC Threads',
               'Dynamic GC Threads', 'Concurrent Explicit GC',
               'Disable Explicit GC', 'Pause Target',
               'GC Time Ratio'
        SELECT LAST(youngCollector), LAST(oldCollector),
               LAST(parallelGCThreads), LAST(concurrentGCThreads),
               LAST(usesDynamicGCThreads), LAST(isExplicitGCConcurrent),
               LAST(isExplicitGCDisabled), LAST(pauseTarget),
               LAST(gcTimeRatio)
        FROM   GCConfiguration"

[jvm.gc-references]
label = "GC References"
table = "COLUMN 'Time', 'GC ID', 'Soft Ref.', 'Weak Ref.', 'Phantom Ref.', 'Final Ref.', 'Total Count'
         SELECT G.startTime, G.gcId, S.count, W.count, P.count, F.count, SUM(G.count)
         FROM GCReferenceStatistics AS S,
              GCReferenceStatistics AS W,
              GCReferenceStatistics AS P,
              GCReferenceStatistics AS F,
              GCReferenceStatistics AS G
         WHERE S.type = 'Soft reference' AND
               W.type = 'Weak reference' AND
               P.type = 'Phantom reference' AND
               F.type = 'Final reference'
         GROUP BY gcId ORDER By G.gcId ASC"

[jvm.gc-pause-phases]
label = "GC Pause Phases"
table = "COLUMN 'Type', 'Name', 'Average',
                'P95', 'Longest', 'Count', 'Total'
         SELECT eventType.label AS T, name,  AVG(duration),
                P95(duration), MAX(duration), COUNT(*), SUM(duration) AS S
         FROM   GCPhasePause, GCPhasePauseLevel1, GCPhasePauseLevel2,
                GCPhasePauseLevel3, GCPhasePauseLevel4 GROUP BY name
         ORDER BY T ASC, S"

[jvm.gc-pauses]
label = "GC Pauses"
form = "COLUMN 'Total Pause Time','Number of Pauses', 'Minimum Pause Time',
               'Median Pause Time', 'Average Pause Time', 'P90 Pause Time',
               'P95 Pause Time', 'P99 Pause Time', 'P99.9% Pause Time',
               'Maximum Pause Time'
        SELECT SUM(duration), COUNT(duration), MIN(duration),
               MEDIAN(duration), AVG(duration), P90(duration),
               P95(duration), P99(duration), P999(duration),
               MAX(duration)
        FROM GCPhasePause"

[jvm.gc-allocation-trigger]
label = "GC Allocation Trigger"
table = "COLUMN 'Trigger Method (Non-JDK)', 'Count', 'Total Requested'
         SELECT stackTrace.topApplicationFrame AS S, COUNT(*), SUM(size)
         FROM AllocationRequiringGC GROUP BY S"

[jvm.gc-cpu-time]
label = "GC CPU Time"
form = "COLUMN 'GC User Time', 'GC System Time',
               'GC Wall Clock Time', 'Total Time',
               'GC Count'
        SELECT SUM(userTime), SUM(systemTime),
               SUM(realTime), DIFF(startTime), COUNT(*)
        FROM GCCPUTime"

[jvm.heap-configuration]
label = "Heap Configuration"
form = "SELECT LAST(initialSize), LAST(minSize), LAST(maxSize),
               LAST(usesCompressedOops), LAST(compressedOopsMode)
               FROM GCHeapConfiguration"

[application.hot-methods]
label = "Java Methods that Executes the Most"
table = "COLUMN 'Method', 'Samples', 'Percent'
         FORMAT none, none, normalized
         SELECT stackTrace.topFrame AS T, COUNT(*), COUNT(*)
         FROM ExecutionSample GROUP BY T LIMIT 25"

[application.cpu-time-hot-methods]
label = "Java Methods that Execute the Most from CPU Time Sampler"
table = "COLUMN 'Method', 'Samples', 'Percent'
         FORMAT none, none, normalized
         SELECT stackTrace.topFrame AS T, COUNT(*), COUNT(*)
         FROM CPUTimeSample GROUP BY T LIMIT 25"

[application.cpu-time-statistics]
label = "CPU Time Sample Statistics"
form = "COLUMN 'Successful Samples', 'Failed Samples', 'Biased Samples', 'Total Samples', 'Lost Samples'
        SELECT COUNT(S.startTime), COUNT(F.startTime), COUNT(B.startTime), Count(A.startTime), SUM(L.lostSamples)
        FROM
          CPUTimeSample AS S,
          CPUTimeSample AS F,
          CPUTimeSample AS A,
          CPUTimeSample AS B,
          CPUTimeSamplesLost AS L
        WHERE
          S.failed = 'false' AND
          F.failed = 'true'  AND
          B.biased = 'true'"

[jvm.jdk-agents]
label = "JDK Agents"
table = "COLUMN 'Time', 'Initialization', 'Name', 'Options'
         FORMAT none, none, truncate-beginning;cell-height:10, cell-height:10
         SELECT LAST(initializationTime) AS t, LAST(initializationDuration), LAST(name), LAST(JavaAgent.options)
         FROM JavaAgent, NativeAgent
         ORDER BY t"

[environment.jvm-flags]
label = "Command Line Flags"
table = "SELECT name AS N, LAST(value)
         FROM IntFlag, UnsignedIntFlag, BooleanFlag,
         LongFlag, UnsignedLongFlag,
         DoubleFlag, StringFlag,
         IntFlagChanged, UnsignedIntFlagChanged, BooleanFlagChanged,
         LongFlagChanged, UnsignedLongFlagChanged,
         DoubleFlagChanged, StringFlagChanged
         GROUP BY name ORDER BY name ASC"

[jvm.jvm-information]
label = "JVM Information"
form = "COLUMN
               'PID', 'VM Start', 'Name', 'Version',
               'VM Arguments', 'Program Arguments'
        SELECT LAST(pid), LAST(jvmStartTime), LAST(jvmName), LAST(jvmVersion),
               LAST(jvmArguments), LAST(javaArguments) FROM JVMInformation"

[application.latencies-by-type]
label = "Latencies by Type"
table = "COLUMN 'Event Type', 'Count', 'Average', 'P 99', 'Longest', 'Total'
         SELECT eventType.label AS T, COUNT(*), AVG(duration),  P99(duration), MAX(duration), SUM(duration)
         FROM JavaMonitorWait, JavaMonitorEnter, ThreadPark, ThreadSleep,
         SocketRead, SocketWrite, FileWrite, FileRead GROUP BY T"

[application.memory-leaks-by-class]
label = "Memory Leak Candidates by Class"
table = "COLUMN 'Alloc. Time', 'Object Class', 'Object Age', 'Heap Usage'
         SELECT LAST_BATCH(allocationTime), LAST_BATCH(object.type), LAST_BATCH(objectAge),
         LAST_BATCH(lastKnownHeapUsage) FROM OldObjectSample GROUP BY object.type ORDER BY allocationTime"

[application.memory-leaks-by-site]
label = "Memory Leak Candidates by Site"
table = "COLUMN 'Alloc. Time', 'Application Method', 'Object Age', 'Heap Usage'
         SELECT LAST_BATCH(allocationTime), LAST_BATCH(stackTrace.topApplicationFrame), LAST_BATCH(objectAge),
         LAST_BATCH(lastKnownHeapUsage) FROM OldObjectSample GROUP BY stackTrace.topApplicationFrame ORDER BY allocationTime"

[application.method-timing]
label = "Method Timing"
table = "COLUMN 'Timed Method', 'Invocations', 'Min. Time', 'Max. Time', 'Average Time'
         FORMAT none, none, ms-precision:6, ms-precision:6, ms-precision:6
         SELECT LAST_BATCH(method) AS M, LAST_BATCH(invocations), LAST_BATCH(minimum), LAST_BATCH(maximum), LAST_BATCH(average)
         FROM jdk.MethodTiming GROUP BY method ORDER BY average"

[application.method-calls]
label = "Method Calls"
table = "COLUMN 'Traced Method', 'Caller', 'Invocations'
         SELECT method as M, stackTrace.topFrame.method AS S, COUNT(*) AS C
         FROM jdk.MethodTrace GROUP BY M, S ORDER BY C DESC"

[application.modules]
label = "Modules"
table = "SELECT LAST(source.name) AS S FROM ModuleRequire GROUP BY source.name ORDER BY S"

[application.monitor-inflation]
label = "Monitor Inflation"
table = "SELECT stackTrace, monitorClass, COUNT(*), SUM(duration) AS S
         FROM jdk.JavaMonitorInflate GROUP BY stackTrace, monitorClass ORDER BY S"

[environment.native-libraries]
label = "Native Libraries"
table = "FORMAT cell-height:2, none, none
         SELECT name AS N, baseAddress, topAddress FROM NativeLibrary GROUP BY name ORDER BY N"

[environment.native-library-failures]
label = "Native Library Load/Unload Failures"
table = "COLUMN 'Operation', 'Library', 'Error Message'
         FORMAT none, truncate-beginning, cell-height:10
         SELECT eventType.label, name, errorMessage
         FROM NativeLibraryUnload, NativeLibraryLoad
         WHERE success = 'false'"

[jvm.native-memory-committed]
label = "Native Memory Committed"
table = "COLUMN 'Memory Type', 'First Observed', 'Average', 'Last Observed', 'Maximum'
         SELECT type, FIRST(committed), AVG(committed), LAST(committed), MAX(committed) AS M
         FROM NativeMemoryUsage GROUP BY type ORDER BY M DESC"

[jvm.native-memory-reserved]
label = "Native Memory Reserved"
table = "COLUMN 'Memory Type', 'First Observed', 'Average', 'Last Observed', 'Maximum'
         SELECT type, FIRST(reserved), AVG(reserved), LAST(reserved), MAX(reserved) AS M
         FROM NativeMemoryUsage GROUP BY type ORDER BY M DESC"

[application.native-methods]
label = "Waiting or Executing Native Methods"
table = "COLUMN 'Method', 'Samples', 'Percent'
         FORMAT none, none, normalized
         SELECT stackTrace.topFrame AS T, COUNT(*), COUNT(*)
         FROM NativeMethodSample GROUP BY T"

[environment.network-utilization]
label = "Network Utilization"
table = "SELECT networkInterface, AVG(readRate), MAX(readRate), AVG(writeRate), MAX(writeRate)
         FROM NetworkUtilization GROUP BY networkInterface"

[application.object-statistics]
label = "Objects Occupying More than 1%"
table = "COLUMN 'Class', 'Count', 'Heap Space', 'Increase'
         SELECT
          LAST_BATCH(objectClass), LAST_BATCH(count),
          LAST_BATCH(totalSize), DIFF(totalSize)
         FROM ObjectCountAfterGC, ObjectCount
         GROUP BY objectClass
         ORDER BY totalSize DESC"

[application.pinned-threads]
label = "Pinned Virtual Threads"
table = "COLUMN 'Method', 'Pinned Count',  'Longest Pinning', 'Total Time Pinned'
         SELECT stackTrace.topApplicationFrame AS S, COUNT(*),
                MAX(duration), SUM(duration) AS T FROM VirtualThreadPinned
         GROUP BY S
         ORDER BY T DESC"

[application.thread-count]
label ="Java Thread Statistics"
table = "SELECT * FROM JavaThreadStatistics"

[environment.recording]
label = "Recording Information"
form = "COLUMN 'Event Count', 'First Recorded Event', 'Last Recorded Event',
                 'Length of Recorded Events', 'Dump Reason'
        SELECT   COUNT(startTime), FIRST(startTime), LAST(startTime),
                 DIFF(startTime), LAST(jdk.Shutdown.reason)
        FROM *"

[jvm.safepoints]
label = "Safepoints"
table = "COLUMN  'Start Time', 'Duration',
                   'State Syncronization',
                   'JNI Critical Threads', 'Total Threads'
         SELECT    B.startTime,  DIFF([B|E].startTime),
                   S.duration,
                   jniCriticalThreadCount, totalThreadCount
         FROM SafepointBegin AS B, SafepointEnd AS E,
              SafepointStateSynchronization AS S
         GROUP BY safepointId ORDER BY B.startTime"

[jvm.longest-compilations]
label = "Longest Compilations"
table = "SELECT startTime, duration AS D, method, compileLevel, succeded
         FROM Compilation ORDER BY D LIMIT 25"

[application.longest-class-loading]
label = "Longest Class Loading"
table = "COLUMN 'Time', 'Loaded Class', 'Load Time'
         SELECT startTime,loadedClass, duration AS D
         FROM ClassLoad ORDER BY D DESC LIMIT 25"

[environment.system-properties]
label = "System Properties at Startup"
table = "FORMAT none, cell-height:25
        SELECT key AS K, value FROM InitialSystemProperty GROUP BY key ORDER by K"

[application.socket-writes-by-host]
label = "Socket Writes by Host"
table = "COLUMN 'Host', 'Writes', 'Total Written'
         FORMAT cell-height:2, none, none
         SELECT host, COUNT(*), SUM(bytesWritten) AS S FROM SocketWrite
         GROUP BY host ORDER BY S DESC"

[application.socket-reads-by-host]
label = "Socket Reads by Host"
table = "COLUMN 'Host', 'Reads', 'Total Read'
         FORMAT cell-height:2, none, none
         SELECT host, COUNT(*), SUM(bytesRead) AS S FROM SocketRead
         GROUP BY host ORDER BY S DESC"

[environment.system-information]
label = "System Information"
form = "COLUMN 'Total Physical Memory Size', 'OS Version', 'Virtualization', 'CPU Type',
                 'Number of Cores', 'Number of Hardware Threads',
                 'Number of Sockets', 'CPU Description'
        SELECT LAST(totalSize), LAST(osVersion), LAST(name), LAST(cpu),
               LAST(cores), LAST(hwThreads),
               LAST(sockets), LAST(description)
        FROM CPUInformation, PhysicalMemory, OSInformation, VirtualizationInformation"

[environment.system-processes]
label = "System Processes"
table = "COLUMN 'First Observed', 'Last Observed', 'PID', 'Command Line'
         FORMAT none, none, none, truncate-beginning
         SELECT FIRST(startTime), LAST(startTime),
                FIRST(pid), FIRST(commandLine)
         FROM SystemProcess GROUP BY pid"

[jvm.tlabs]
label = "Thread Local Allocation Buffers"
form = "COLUMN 'Inside TLAB Count', 'Inside TLAB Minimum Size', 'Inside TLAB Average Size',
               'Inside TLAB Maximum Size', 'Inside TLAB Total Allocation',
               'Outside TLAB Count',  'OutSide TLAB Minimum Size', 'Outside TLAB Average Size',
               'Outside TLAB Maximum Size', 'Outside TLAB Total Allocation'
        SELECT  COUNT(I.tlabSize), MIN(I.tlabSize), AVG(I.tlabSize),
                MAX(I.tlabSize), SUM(I.tlabSize),
                COUNT(O.allocationSize), MIN(O.allocationSize), AVG(O.allocationSize),
                MAX(O.allocationSize), SUM(O.allocationSize)
        FROM ObjectAllocationInNewTLAB AS I, ObjectAllocationOutsideTLAB AS O"

[application.thread-allocation]
label = "Thread Allocation Statistics"
table = "COLUMN 'Thread', 'Allocated', 'Percentage'
         FORMAT none, none, normalized
         SELECT thread, LAST(allocated), LAST(allocated) AS A FROM ThreadAllocationStatistics
         GROUP BY thread ORDER BY A DESC"

[application.thread-cpu-load]
label = "Thread CPU Load"
table = "COLUMN 'Thread', 'System', 'User'
         SELECT eventThread AS E, LAST(system), LAST(user) AS U
         FROM ThreadCPULoad GROUP BY E ORDER BY U DESC"

[application.thread-start]
label = "Platform Thread Start by Method"
table = "COLUMN 'Start Time','Stack Trace', 'Thread', 'Duration'
         SELECT S.startTime, S.stackTrace, eventThread, DIFF(startTime) AS D
         FROM ThreadStart AS S, ThreadEnd AS E GROUP
         by eventThread ORDER BY D DESC"

[jvm.vm-operations]
label = "VM Operations"
table = "COLUMN 'VM Operation', 'Average Duration', 'Longest Duration', 'Count' , 'Total Duration'
         SELECT operation,  AVG(duration), MAX(duration), COUNT(*), SUM(duration)
         FROM jdk.ExecuteVMOperation GROUP BY operation"