Java Code Examples for jdk.jfr.Recording#disable()

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

    ClassLoader classLoader = TestLoadEventAfterStart.class.getClassLoader();
    Class<? extends Event> eventClass =
        classLoader.loadClass("jdk.testlibrary.jfr.SimpleEvent").asSubclass(Event.class);

    r.enable(eventClass).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    createEvent(eventClass, 1);
    r.disable(eventClass);
    createEvent(eventClass, 2);
    r.enable(eventClass).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    createEvent(eventClass, 3);

    r.stop();
    verifyEvents(r, 1, 3);
}
 

private static void updateSettings(Recording r) {
    int operationIndex = rand.nextInt(4);
    switch (operationIndex) {
        case 0:
            SimpleEventHelper.enable(r, true);
            break;
        case 1:
            SimpleEventHelper.enable(r, false);
            break;
        case 2:
            r.enable(EVENT_PATH).withoutStackTrace();
            break;
        case 3:
            r.disable(EVENT_PATH);
            break;
        default:
            Asserts.fail("Wrong operataionIndex. Test error");
        }
}
 

private static void updateSettings(Recording r) {
    int operationIndex = rand.nextInt(4);
    switch (operationIndex) {
        case 0:
            SimpleEventHelper.enable(r, true);
            break;
        case 1:
            SimpleEventHelper.enable(r, false);
            break;
        case 2:
            r.enable(EVENT_PATH).withoutStackTrace();
            break;
        case 3:
            r.disable(EVENT_PATH);
            break;
        default:
            Asserts.fail("Wrong operataionIndex. Test error");
        }
}
 

public static void enable(Recording r, boolean isEnabled) {
    if (isEnabled) {
        r.enable(MyEvent.class).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    } else {
        r.disable(MyEvent.class);
    }
}
 

public static void main(String[] args) throws Exception {
    List<MyEvent> expectedEvents = new ArrayList<>();
    Recording r = new Recording();

    r.start();
    createEvent(expectedEvents, true); // id=0 Custom event classes are enabled by default.

    r.disable(MyEvent.class);
    createEvent(expectedEvents, false); // id=1
    r.enable(MyEvent.class);
    createEvent(expectedEvents, true);  // id=2

    // enable/disable by event setting name
    String eventSettingName = String.valueOf(EventType.getEventType(MyEvent.class).getId());
    System.out.println("eventSettingName=" + eventSettingName);

    r.disable(eventSettingName);
    createEvent(expectedEvents, false); // id=3
    r.enable(eventSettingName);
    createEvent(expectedEvents, true);

    r.stop();
    createEvent(expectedEvents, false);

    Iterator<MyEvent> expectedIterator = expectedEvents.iterator();
    for (RecordedEvent event : Events.fromRecording(r)) {
        System.out.println("event.id=" + Events.assertField(event, "id").getValue());
        Asserts.assertTrue(expectedIterator.hasNext(), "Found more events than expected");
        Events.assertField(event, "id").equal(expectedIterator.next().id);
    }
    Asserts.assertFalse(expectedIterator.hasNext(), "Did not find all expected events.");

    r.close();
}
 

public static void enable(Recording r, boolean isEnabled) {
    if (isEnabled) {
        r.enable(MyEvent.class).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    } else {
        r.disable(MyEvent.class);
    }
}
 

public static void enable(Recording r, boolean isEnabled) {
    if (isEnabled) {
        r.enable(SimpleEvent.class).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    } else {
        r.disable(SimpleEvent.class);
    }
}
 

private static void updateSettings(Recording r) {
    boolean doEnable = rand.nextInt(3) == 0; // Disable 2 of 3, since event
                                             // is enabled by union of
                                             // recordings.
    boolean doMyEvent = rand.nextInt(2) == 0;
    if (doMyEvent) {
        SimpleEventHelper.enable(r, doEnable);
    } else {
        if (doEnable) {
            r.enable(EVENT_PATH).withoutStackTrace();
        } else {
            r.disable(EVENT_PATH);
        }
    }
}
 

public static void enable(Recording r, boolean isEnabled) {
    if (isEnabled) {
        r.enable(SimpleEvent.class).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    } else {
        r.disable(SimpleEvent.class);
    }
}
 

public static void main(String[] args) throws Exception {
    assertDisabled("Event enabled with no recording");

    Recording r = new Recording();
    assertDisabled("Event enabled at new Recording()");

    r.enable(SimpleEvent.class);
    assertDisabled("Event enabled before r.start()");

    r.start();

    // enable/disable by class
    assertEnabled("Event not enabled after r.start()");
    r.disable(SimpleEvent.class);
    assertDisabled("Event enabled after r.disable()");
    r.enable(SimpleEvent.class);
    assertEnabled("Event disabled afer r.enable()");

    // enable/disable by event setting name
    String eventSettingName = String.valueOf(EventType.getEventType(SimpleEvent.class).getId());
    System.out.println("eventSettingName=" + eventSettingName);

    r.disable(eventSettingName);
    assertDisabled("Event enabled after r.disable(name)");
    r.enable(eventSettingName);
    assertEnabled("Event disabled after r.enable(name)");

    r.stop();
    assertDisabled("Event enabled after r.stop()");

    r.close();
    assertDisabled("Event enabled after r.close()");
}
 

public static void enable(Recording r, boolean isEnabled) {
    if (isEnabled) {
        r.enable(SimpleEvent.class).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    } else {
        r.disable(SimpleEvent.class);
    }
}
 

public static void enable(Recording r, boolean isEnabled) {
    if (isEnabled) {
        r.enable(MyEvent.class).withThreshold(Duration.ofMillis(0)).withoutStackTrace();
    } else {
        r.disable(MyEvent.class);
    }
}
 

private static void updateSettings(Recording r) {
    boolean doEnable = rand.nextInt(3) == 0; // Disable 2 of 3, since event
                                             // is enabled by union of
                                             // recordings.
    boolean doMyEvent = rand.nextInt(2) == 0;
    if (doMyEvent) {
        SimpleEventHelper.enable(r, doEnable);
    } else {
        if (doEnable) {
            r.enable(EVENT_PATH).withoutStackTrace();
        } else {
            r.disable(EVENT_PATH);
        }
    }
}
 

private static void updateSettings(Recording r) {
    boolean doEnable = rand.nextInt(3) == 0; // Disable 2 of 3, since event
                                             // is enabled by union of
                                             // recordings.
    boolean doMyEvent = rand.nextInt(2) == 0;
    if (doMyEvent) {
        SimpleEventHelper.enable(r, doEnable);
    } else {
        if (doEnable) {
            r.enable(EVENT_PATH).withoutStackTrace();
        } else {
            r.disable(EVENT_PATH);
        }
    }
}
 

public static void main(String[] args) throws Throwable {
    final long minThresholdNanos = 1000000;
    final String dummyEventPath = "mydummy/event/path";
    final String myEventSettingName = String.valueOf(EventType.getEventType(MyEvent.class).getId());
    System.out.println("myEventSettingName=" + myEventSettingName);

    // Settings should be merged to include the most number of events (minimum threshold).
    Recording r1 = new Recording();
    r1.enable(MyEvent.class).withThreshold(Duration.ofNanos(minThresholdNanos * 3));
    r1.enable(MyEvent.class).withThreshold(Duration.ofNanos(minThresholdNanos * 2));
    r1.enable(dummyEventPath).withThreshold(Duration.ofNanos(minThresholdNanos));
    r1.start();

    ExpectedSetting[] expectedR1 = {
        new ExpectedSetting(myEventSettingName, "enabled", "true"),
        new ExpectedSetting(myEventSettingName, "threshold", Long.toString(minThresholdNanos * 2) + " ns"),
        new ExpectedSetting(dummyEventPath, "enabled", "true"),
        new ExpectedSetting(dummyEventPath, "threshold", Long.toString(minThresholdNanos) + " ns"),
    };

    verifySettings(r1.getSettings(), expectedR1);

    // Start another recording. Recorder settings should be merged from both recordings.
    Recording r2 = new Recording();
    r2.enable(MyEvent.class).withThreshold(Duration.ofNanos(minThresholdNanos));
    r2.disable(dummyEventPath);
    r2.start();

    ExpectedSetting[] expectedR2 = {
        new ExpectedSetting(myEventSettingName, "enabled", "true"),
        new ExpectedSetting(myEventSettingName, "threshold", Long.toString(minThresholdNanos) + " ns"),
        new ExpectedSetting(dummyEventPath, "enabled", "false")
    };

    verifySettings(r1.getSettings(), expectedR1);
    verifySettings(r2.getSettings(), expectedR2);

    // Stop first recording. Recorder should use settings from r2.
    r1.stop();
    verifySettings(r2.getSettings(), expectedR2);

    r2.stop();
    r1.close();
    r2.close();
}
 

private static void assertEnabled(RecState recStateA, RecState recStateB, EnableState enableStateA, EnableState enableStateB) {

        Recording a = new Recording();
        Recording b = new Recording();
        assertEnablement(false); // no recording running

        if (enableStateA == EnableState.Disabled) {
            a.disable(MyEvent.class);
        }
        if (enableStateA == EnableState.Enabled) {
            a.enable(MyEvent.class);
        }
        if (enableStateB == EnableState.Disabled) {
            b.disable(MyEvent.class);
        }
        if (enableStateB == EnableState.Enabled) {
            b.enable(MyEvent.class);
        }
        if ( enableStateA == EnableState.Disabled && recStateA == RecState.Running) {
            if ( enableStateB == EnableState.Disabled && recStateB == RecState.Running) {
                System.out.println();
            }
        }
        if (recStateA == RecState.Running) {
            a.start();
        }
        if (recStateB == RecState.Running) {
            b.start();
        }

        System.out.println("Recording a is " + a.getState() + ". Event is " + enableStateA);
        System.out.println("Recording b is " + b.getState() + ". Event is " + enableStateB);
        // an event is enabled if at least one recording is running
        // and the event is on by default or has been enabled.
        boolean aEnabled = recStateA == RecState.Running && enableStateA == EnableState.Enabled;
        boolean bEnabled = recStateB == RecState.Running && enableStateB == EnableState.Enabled;
        boolean enabled = aEnabled || bEnabled;
        System.out.println("Expected enablement: " + enabled);
        System.out.println();
        assertEnablement(enabled);
        if (recStateA == RecState.Running) {
            a.stop();
        }
        if (recStateB == RecState.Running) {
            b.stop();
        }
        assertEnablement(false); // no recording running
        a.close();
        b.close();
    }
 

private static void testRecordingWithEnabledEvent(String eventname, boolean enabled) throws Exception {
    System.out.println("Testing enabled=" + enabled + " for " + eventname);
    final Path pathDisabled = Paths.get(".", "disabled.txt").toAbsolutePath();
    final Path pathEnabled = Paths.get(".", "enabled.txt").toAbsolutePath();

    Recording r = new Recording();
    if (enabled) {
        r.enable(eventname).withoutThreshold().withoutStackTrace();
    } else {
        r.disable(eventname).withoutThreshold().withoutStackTrace();
    }
    r.start();

    // We should only get events for pathEnabled, not for pathDisabled.
    int countExpectedEvents = 0;
    for (int i = 0; i < 10; ++i) {
        if (enabled) {
            Files.write(pathEnabled, "E".getBytes());
            ++countExpectedEvents;
            r.disable(eventname);
        } else {
            Files.write(pathDisabled, "D".getBytes());
            r.enable(eventname);
        }
        enabled = !enabled;
    }
    r.stop();

    int countFoundEvents = 0;
    for (RecordedEvent event : Events.fromRecording(r)) {
        System.out.printf("Event %s%n", event);
        Asserts.assertEquals(eventname, event.getEventType().getName(), "Wrong event type");
        String path = Events.assertField(event, "path").getValue();
        System.out.println(path);
        if (pathEnabled.toString().equals(path)) {
            ++countFoundEvents;
        }
    }
    Asserts.assertGreaterThanOrEqual(countFoundEvents, countExpectedEvents, "Too few events found");

    r.close();
}
 

private static void assertEnabled(RecState recStateA, RecState recStateB, EnableState enableStateA, EnableState enableStateB) {

        Recording a = new Recording();
        Recording b = new Recording();
        assertEnablement(false); // no recording running

        if (enableStateA == EnableState.Disabled) {
            a.disable(MyEvent.class);
        }
        if (enableStateA == EnableState.Enabled) {
            a.enable(MyEvent.class);
        }
        if (enableStateB == EnableState.Disabled) {
            b.disable(MyEvent.class);
        }
        if (enableStateB == EnableState.Enabled) {
            b.enable(MyEvent.class);
        }
        if ( enableStateA == EnableState.Disabled && recStateA == RecState.Running) {
            if ( enableStateB == EnableState.Disabled && recStateB == RecState.Running) {
                System.out.println();
            }
        }
        if (recStateA == RecState.Running) {
            a.start();
        }
        if (recStateB == RecState.Running) {
            b.start();
        }

        System.out.println("Recording a is " + a.getState() + ". Event is " + enableStateA);
        System.out.println("Recording b is " + b.getState() + ". Event is " + enableStateB);
        // an event is enabled if at least one recording is running
        // and the event is on by default or has been enabled.
        boolean aEnabled = recStateA == RecState.Running && enableStateA == EnableState.Enabled;
        boolean bEnabled = recStateB == RecState.Running && enableStateB == EnableState.Enabled;
        boolean enabled = aEnabled || bEnabled;
        System.out.println("Expected enablement: " + enabled);
        System.out.println();
        assertEnablement(enabled);
        if (recStateA == RecState.Running) {
            a.stop();
        }
        if (recStateB == RecState.Running) {
            b.stop();
        }
        assertEnablement(false); // no recording running
        a.close();
        b.close();
    }
 

private static void testRecordingWithEnabledEvent(String eventname, boolean enabled) throws Exception {
    System.out.println("Testing enabled=" + enabled + " for " + eventname);
    final Path pathDisabled = Paths.get(".", "disabled.txt").toAbsolutePath();
    final Path pathEnabled = Paths.get(".", "enabled.txt").toAbsolutePath();

    Recording r = new Recording();
    if (enabled) {
        r.enable(eventname).withoutThreshold().withoutStackTrace();
    } else {
        r.disable(eventname).withoutThreshold().withoutStackTrace();
    }
    r.start();

    // We should only get events for pathEnabled, not for pathDisabled.
    int countExpectedEvents = 0;
    for (int i = 0; i < 10; ++i) {
        if (enabled) {
            Files.write(pathEnabled, "E".getBytes());
            ++countExpectedEvents;
            r.disable(eventname);
        } else {
            Files.write(pathDisabled, "D".getBytes());
            r.enable(eventname);
        }
        enabled = !enabled;
    }
    r.stop();

    int countFoundEvents = 0;
    for (RecordedEvent event : Events.fromRecording(r)) {
        System.out.printf("Event %s%n", event);
        Asserts.assertEquals(eventname, event.getEventType().getName(), "Wrong event type");
        String path = Events.assertField(event, "path").getValue();
        System.out.println(path);
        if (pathEnabled.toString().equals(path)) {
            ++countFoundEvents;
        }
    }
    Asserts.assertGreaterThanOrEqual(countFoundEvents, countExpectedEvents, "Too few events found");

    r.close();
}
 

public static void main(String[] args) throws Exception {
    Recording rA = new Recording();

    verifyShouldCommitFalse(); // No active recordings

    rA.start();
    rA.enable(MyEvent.class).withoutThreshold(); // recA=all
    verifyShouldCommitTrue();

    setThreshold(rA, 100); // recA=100
    verifyThreshold(100);

    setThreshold(rA, 200); // recA=200
    verifyThreshold(200);

    Recording rB = new Recording();
    verifyThreshold(200);  // recA=200, recB=not started

    rB.start();
    verifyThreshold(200);  // recA=200, recB=not specified, settings from recA is used.

    setThreshold(rB, 100); // recA=200, recB=100
    verifyThreshold(100);

    setThreshold(rB, 300); // recA=200, recB=300
    verifyThreshold(200);

    rA.disable(MyEvent.class); // recA=disabled, recB=300

    verifyThreshold(300);

    rB.disable(MyEvent.class); // recA=disabled, recB=disabled
    verifyShouldCommitFalse();

    setThreshold(rA, 200); // recA=200, recB=disabled
    verifyThreshold(200);

    rB.enable(MyEvent.class).withoutThreshold(); // recA=200, recB=all
    verifyShouldCommitTrue();

    setThreshold(rB, 100); // recA=200, recB=100
    verifyThreshold(100);

    rB.stop(); // recA=200, recB=stopped
    verifyThreshold(200);

    rA.stop(); // recA=stopped, recB=stopped
    verifyShouldCommitFalse();

    rA.close();
    rB.close();

    verifyShouldCommitFalse();
}