Java Code Examples for jdk.jfr.consumer.RecordedStackTrace#getFrames()

private void printStackTrace(RecordedStackTrace stackTrace) {
    println("[");
    List<RecordedFrame> frames = stackTrace.getFrames();
    indent();
    int i = 0;
    while (i < frames.size() && i < getStackDepth()) {
        RecordedFrame frame = frames.get(i);
        if (frame.isJavaFrame()) {
            printIndent();
            printValue(frame, null, "");
            println();
            i++;
        }
    }
    if (stackTrace.isTruncated() || i == getStackDepth()) {
        printIndent();
        println("...");
    }
    retract();
    printIndent();
    println("]");
}
 

public static void main(String[] args) throws Throwable {
    Recording recording = new Recording();
    recording.enable(MyEvent.class).withStackTrace();
    recording.start();

    MyEvent event = new MyEvent();
    event.begin();
    event.end();
    event.commit();
    recording.stop();

    List<RecordedEvent> recordedEvents = Events.fromRecording(recording);
    assertEquals(1, recordedEvents.size(), "Expected one event");
    RecordedEvent recordedEvent = recordedEvents.get(0);

    RecordedStackTrace stacktrace = recordedEvent.getStackTrace();
    List<RecordedFrame> frames = stacktrace.getFrames();
    assertFalse(frames.isEmpty(), "Stacktrace frames was empty");
    for (RecordedFrame frame : frames) {
        analyzeRecordedMethodDescriptor(frame.getMethod());
    }

    assertTrue(isMainMethodDescriptorRecorded, "main() method descriptor has never been recorded");
}
 

private static boolean matchingStackTrace(RecordedStackTrace stack, String[] expectedStack) {
    if (stack == null) {
        return false;
    }

    List<RecordedFrame> frames = stack.getFrames();
    int pos = findFramePos(frames, expectedStack[0]);

    if (pos == -1) {
        return false;
    }

    for (String expectedFrame : expectedStack) {
        RecordedFrame f = frames.get(pos++);
        String frame = frameToString(f);

        if (!frame.equals(expectedFrame)) {
            return false;
        }
    }

    return true;
}
 

public static void main(String[] args) throws Throwable {
    Recording recording = new Recording();
    recording.enable(MyEvent.class).withStackTrace();
    recording.start();

    MyEvent event = new MyEvent();
    event.begin();
    event.end();
    event.commit();
    recording.stop();

    List<RecordedEvent> recordedEvents = Events.fromRecording(recording);
    assertEquals(1, recordedEvents.size(), "Expected one event");
    RecordedEvent recordedEvent = recordedEvents.get(0);

    RecordedStackTrace stacktrace = recordedEvent.getStackTrace();
    List<RecordedFrame> frames = stacktrace.getFrames();
    assertFalse(frames.isEmpty(), "Stacktrace frames was empty");
    for (RecordedFrame frame : frames) {
        analyzeRecordedMethodDescriptor(frame.getMethod());
    }

    assertTrue(isMainMethodDescriptorRecorded, "main() method descriptor has never been recorded");
}
 

public static boolean matchingStackTrace(RecordedStackTrace stack, String[] expectedStack) {
    if (stack == null) {
        return false;
    }

    List<RecordedFrame> frames = stack.getFrames();
    int pos = findFramePos(frames, expectedStack[0]);

    if (pos == -1) {
        return false;
    }

    for (String expectedFrame : expectedStack) {
        RecordedFrame f = frames.get(pos++);
        String frame = frameToString(f);

        if (!frame.contains(expectedFrame)) {
            return false;
        }
    }
    return true;
}
 

public static boolean matchingStackTrace(RecordedStackTrace stack, String[] expectedStack) {
    if (stack == null) {
        return false;
    }

    List<RecordedFrame> frames = stack.getFrames();
    int pos = findFramePos(frames, expectedStack[0]);

    if (pos == -1) {
        return false;
    }

    for (String expectedFrame : expectedStack) {
        RecordedFrame f = frames.get(pos++);
        String frame = frameToString(f);

        if (!frame.contains(expectedFrame)) {
            return false;
        }
    }
    return true;
}
 

public static boolean matchingStackTrace(RecordedStackTrace stack, String[] expectedStack) {
    if (stack == null) {
        return false;
    }

    List<RecordedFrame> frames = stack.getFrames();
    int pos = findFramePos(frames, expectedStack[0]);

    if (pos == -1) {
        return false;
    }

    for (String expectedFrame : expectedStack) {
        RecordedFrame f = frames.get(pos++);
        String frame = frameToString(f);

        if (!frame.contains(expectedFrame)) {
            return false;
        }
    }
    return true;
}
 

private static boolean matchingStackTrace(RecordedStackTrace stack, String[] expectedStack) {
    if (stack == null) {
        return false;
    }

    List<RecordedFrame> frames = stack.getFrames();
    int pos = findFramePos(frames, expectedStack[0]);

    if (pos == -1) {
        return false;
    }

    for (String expectedFrame : expectedStack) {
        RecordedFrame f = frames.get(pos++);
        String frame = frameToString(f);

        if (!frame.equals(expectedFrame)) {
            return false;
        }
    }

    return true;
}
 

private static boolean matchingStackTrace(RecordedStackTrace stack, String[] expectedStack) {
    if (stack == null) {
        return false;
    }

    List<RecordedFrame> frames = stack.getFrames();
    int pos = findFramePos(frames, expectedStack[0]);

    if (pos == -1) {
        return false;
    }

    for (String expectedFrame : expectedStack) {
        RecordedFrame f = frames.get(pos++);
        String frame = frameToString(f);

        if (!frame.equals(expectedFrame)) {
            return false;
        }
    }

    return true;
}
 

private static void assertStackTrace(RecordedStackTrace stacktrace, final String methodName) {
    for (RecordedFrame f : stacktrace.getFrames()) {
        if (f.getMethod().getName().equals(methodName)) {
            return;
        }
    }
    Asserts.fail("Could not find class " + methodName + " in stack trace " + stacktrace);
}
 

private static void assertStackTrace(RecordedEvent re) {
    assertNotNull(re.getStackTrace());
    RecordedStackTrace strace = re.getStackTrace();
    assertEquals(strace.isTruncated(), false);
    List<RecordedFrame> frames = strace.getFrames();
    assertTrue(frames.size() > 0);
    for (RecordedFrame frame : frames) {
        assertFrame(frame);
    }
}
 

public static void main(String[] args) throws Throwable {
    Recording recording = new Recording();
    recording.start();

    SimpleEvent ev = new SimpleEvent();
    ev.commit();
    recording.stop();

    List<RecordedEvent> recordedEvents = Events.fromRecording(recording);
    Events.hasEvents(recordedEvents);
    RecordedEvent recordedEvent = recordedEvents.get(0);

    System.out.println("recorded event:" + recordedEvent);

    RecordedStackTrace stacktrace = recordedEvent.getStackTrace();
    List<RecordedFrame> frames = stacktrace.getFrames();
    for (RecordedFrame frame : frames) {
        RecordedMethod method = frame.getMethod();
        if (method.getName().equals("main")) {
            System.out.println("'main' method: " + method);
            int modifiers = TestMethodGetModifiers.class.getDeclaredMethod("main", (Class<?>)String[].class).getModifiers();
            System.out.println("modifiers: " + modifiers);
            Asserts.assertEquals(method.getModifiers(), modifiers, "Incorrect method modifier reported");
            RecordedClass type = method.getType();
            assertNotNull(type, "Recorded class can not be null");
        }

    }
}
 

public static void main(String[] args) throws Throwable {
    Recording recording = new Recording();
    recording.start();

    SimpleEvent ev = new SimpleEvent();
    ev.commit();
    recording.stop();

    List<RecordedEvent> recordedEvents = Events.fromRecording(recording);
    Events.hasEvents(recordedEvents);
    RecordedEvent recordedEvent = recordedEvents.get(0);

    System.out.println("recorded event:" + recordedEvent);

    RecordedStackTrace stacktrace = recordedEvent.getStackTrace();
    List<RecordedFrame> frames = stacktrace.getFrames();
    for (RecordedFrame frame : frames) {
        RecordedMethod method = frame.getMethod();
        if (method.getName().equals("main")) {
            System.out.println("'main' method: " + method);
            int modifiers = TestMethodGetModifiers.class.getDeclaredMethod("main", (Class<?>)String[].class).getModifiers();
            System.out.println("modifiers: " + modifiers);
            Asserts.assertEquals(method.getModifiers(), modifiers, "Incorrect method modifier reported");
            RecordedClass type = method.getType();
            assertNotNull(type, "Recorded class can not be null");
        }

    }
}
 

private static void checkEvent(RecordedEvent event, int expectedDepth) throws Throwable {
    RecordedStackTrace stacktrace = null;
    try {
        stacktrace = event.getStackTrace();
        List<RecordedFrame> frames = stacktrace.getFrames();
        Asserts.assertEquals(Math.min(MAX_DEPTH, expectedDepth), frames.size(), "Wrong stacktrace depth. Expected:" + expectedDepth);
        List<String> expectedMethods = getExpectedMethods(expectedDepth);
        Asserts.assertEquals(expectedMethods.size(), frames.size(), "Wrong expectedMethods depth. Test error.");

        for (int i = 0; i < frames.size(); ++i) {
            String name = frames.get(i).getMethod().getName();
            String expectedName = expectedMethods.get(i);
            System.out.printf("method[%d]=%s, expected=%s%n", i, name, expectedName);
            Asserts.assertEquals(name, expectedName, "Wrong method name");
        }

        boolean isTruncated = stacktrace.isTruncated();
        boolean isTruncateExpected = expectedDepth > MAX_DEPTH;
        Asserts.assertEquals(isTruncated, isTruncateExpected, "Wrong value for isTruncated. Expected:" + isTruncateExpected);

        String firstMethod = frames.get(frames.size() - 1).getMethod().getName();
        boolean isFullTrace = "run".equals(firstMethod);
        String msg = String.format("Wrong values for isTruncated=%b, isFullTrace=%b", isTruncated, isFullTrace);
        Asserts.assertTrue(isTruncated != isFullTrace, msg);
    } catch (Throwable t) {
        System.out.println(String.format("stacktrace:%n%s", stacktrace));
        throw t;
    }
}
 

private void checkEvent(RecordedEvent event) throws Exception {
    // skip check if allocation failure comes not from diver

    RecordedThread thread = event.getThread();
    String threadName = thread.getJavaName();

    if (!threadName.contains(THREAD_NAME)) {
        System.out.println("Skip event not from pool (from internals)");
        System.out.println(" Thread Id: " + thread.getJavaThreadId()
                + " Thread name: " + threadName);
        return;
    }

    RecordedStackTrace stackTrace = event.getStackTrace();

    List<RecordedFrame> frames = stackTrace.getFrames();
    //String[] stacktrace = StackTraceHelper.buildStackTraceFromFrames(frames);

    if (!(frames.get(0).getMethod().getName().equals(DIVER_FRAME_NAME))) {
        System.out.println("Skip stacktrace check for: \n"
                + String.join("\n", threadName));
        return;
    }

    assertTrue(frames.size() > RECURSION_DEPTH,
            "Stack trace should contain at least one more entry than the ones generated by the test recursion");
    for (int i = 0; i < RECURSION_DEPTH; i++) {
        assertEquals(frames.get(i).getMethod().getName(), DIVER_FRAME_NAME,
                "Frame " + i + " is wrong: \n"
                + String.join("\n", threadName));
    }
    assertNotEquals(frames.get(RECURSION_DEPTH).getMethod().getName(), DIVER_FRAME_NAME,
            "Too many diver frames: \n"
            + String.join("\n", threadName));
}
 

private static void assertStackTrace(RecordedEvent re) {
    assertNotNull(re.getStackTrace());
    RecordedStackTrace strace = re.getStackTrace();
    assertEquals(strace.isTruncated(), false);
    List<RecordedFrame> frames = strace.getFrames();
    assertTrue(frames.size() > 0);
    for (RecordedFrame frame : frames) {
        assertFrame(frame);
    }
}
 

private static void assertStackTrace(RecordedEvent re) {
    assertNotNull(re.getStackTrace());
    RecordedStackTrace strace = re.getStackTrace();
    assertEquals(strace.isTruncated(), false);
    List<RecordedFrame> frames = strace.getFrames();
    assertTrue(frames.size() > 0);
    for (RecordedFrame frame : frames) {
        assertFrame(frame);
    }
}
 

private static void checkEvent(RecordedEvent event, int expectedDepth) throws Throwable {
    RecordedStackTrace stacktrace = null;
    try {
        stacktrace = event.getStackTrace();
        List<RecordedFrame> frames = stacktrace.getFrames();
        Asserts.assertEquals(Math.min(MAX_DEPTH, expectedDepth), frames.size(), "Wrong stacktrace depth. Expected:" + expectedDepth);
        List<String> expectedMethods = getExpectedMethods(expectedDepth);
        Asserts.assertEquals(expectedMethods.size(), frames.size(), "Wrong expectedMethods depth. Test error.");

        for (int i = 0; i < frames.size(); ++i) {
            String name = frames.get(i).getMethod().getName();
            String expectedName = expectedMethods.get(i);
            System.out.printf("method[%d]=%s, expected=%s%n", i, name, expectedName);
            Asserts.assertEquals(name, expectedName, "Wrong method name");
        }

        boolean isTruncated = stacktrace.isTruncated();
        boolean isTruncateExpected = expectedDepth > MAX_DEPTH;
        Asserts.assertEquals(isTruncated, isTruncateExpected, "Wrong value for isTruncated. Expected:" + isTruncateExpected);

        String firstMethod = frames.get(frames.size() - 1).getMethod().getName();
        boolean isFullTrace = "run".equals(firstMethod);
        String msg = String.format("Wrong values for isTruncated=%b, isFullTrace=%b", isTruncated, isFullTrace);
        Asserts.assertTrue(isTruncated != isFullTrace, msg);
    } catch (Throwable t) {
        System.out.println(String.format("stacktrace:%n%s", stacktrace));
        throw t;
    }
}
 

static void validateStackTrace(RecordedStackTrace stackTrace) {
    List<RecordedFrame> frames = stackTrace.getFrames();
    Asserts.assertFalse(frames.isEmpty());
    Asserts.assertTrue(frames.stream()
                       .anyMatch(t -> t.getMethod().getName().equals("runTest")));
}
 

public static void doTest(int lineNumber) throws IOException {

        System.out.println("Enetring method");

        Recording recording = new Recording();
        recording.start();

        SimpleEvent ev = new SimpleEvent();
        commitEvent(ev);
        recording.stop();

        List<RecordedEvent> recordedEvents = Events.fromRecording(recording);
        Events.hasEvents(recordedEvents);
        RecordedEvent recordedEvent = recordedEvents.get(0);

        RecordedStackTrace stacktrace = recordedEvent.getStackTrace();
        List<RecordedFrame> frames = stacktrace.getFrames();
        for (RecordedFrame frame : frames) {

            // All frames are java frames
            Asserts.assertTrue(frame.isJavaFrame());
            // Verify the main() method frame
            RecordedMethod method = frame.getMethod();
            if (method.getName().equals("main")) {

                // Frame type
                String type = frame.getType();
                System.out.println("type: " + type);
                Asserts.assertTrue(
                        type.equals("Interpreted")
                        || type.equals("JIT compiled")
                        || type.equals("Inlined"));

                Asserts.assertEquals(lineNumber, frame.getLineNumber());

                boolean isInterpreted = "Interpreted".equals(type);
                boolean expectedInterpreted = "true".equals(System.getProperty("interpreted"));
                Asserts.assertEquals(isInterpreted, expectedInterpreted);

                int bci = frame.getBytecodeIndex();

                System.out.println("bci: " + bci);
                Asserts.assertTrue(bci > 0);
            }

        }

    }