Java Code Examples for jdk.jfr.EventFactory#create()

public static void testEventFactoryExample() throws IOException {
     List<ValueDescriptor> fields = new ArrayList<>();
     List<AnnotationElement> messageAnnotations = Collections.singletonList(new AnnotationElement(Label.class, "Message"));
     fields.add(new ValueDescriptor(String.class, "message", messageAnnotations));
     List<AnnotationElement> numberAnnotations = Collections.singletonList(new AnnotationElement(Label.class, "Number"));
     fields.add(new ValueDescriptor(int.class, "number", numberAnnotations));

     String[] category = { "Example", "Getting Started" };
     List<AnnotationElement> eventAnnotations = new ArrayList<>();
     eventAnnotations.add(new AnnotationElement(Name.class, "com.example.HelloWorld"));
     eventAnnotations.add(new AnnotationElement(Label.class, "Hello World"));
     eventAnnotations.add(new AnnotationElement(Description.class, "Helps programmer getting started"));
     eventAnnotations.add(new AnnotationElement(Category.class, category));

     EventFactory f = EventFactory.create(eventAnnotations, fields);

     Event event = f.newEvent();
     event.set(0, "hello, world!");
     event.set(1, 4711);
     event.commit();
}
 

public static void testEventFactoryExample() throws IOException {
     List<ValueDescriptor> fields = new ArrayList<>();
     List<AnnotationElement> messageAnnotations = Collections.singletonList(new AnnotationElement(Label.class, "Message"));
     fields.add(new ValueDescriptor(String.class, "message", messageAnnotations));
     List<AnnotationElement> numberAnnotations = Collections.singletonList(new AnnotationElement(Label.class, "Number"));
     fields.add(new ValueDescriptor(int.class, "number", numberAnnotations));

     String[] category = { "Example", "Getting Started" };
     List<AnnotationElement> eventAnnotations = new ArrayList<>();
     eventAnnotations.add(new AnnotationElement(Name.class, "com.example.HelloWorld"));
     eventAnnotations.add(new AnnotationElement(Label.class, "Hello World"));
     eventAnnotations.add(new AnnotationElement(Description.class, "Helps programmer getting started"));
     eventAnnotations.add(new AnnotationElement(Category.class, category));

     EventFactory f = EventFactory.create(eventAnnotations, fields);

     Event event = f.newEvent();
     event.set(0, "hello, world!");
     event.set(1, 4711);
     event.commit();
}
 

public static void testEventFactoryExample() throws IOException {
     List<ValueDescriptor> fields = new ArrayList<>();
     List<AnnotationElement> messageAnnotations = Collections.singletonList(new AnnotationElement(Label.class, "Message"));
     fields.add(new ValueDescriptor(String.class, "message", messageAnnotations));
     List<AnnotationElement> numberAnnotations = Collections.singletonList(new AnnotationElement(Label.class, "Number"));
     fields.add(new ValueDescriptor(int.class, "number", numberAnnotations));

     String[] category = { "Example", "Getting Started" };
     List<AnnotationElement> eventAnnotations = new ArrayList<>();
     eventAnnotations.add(new AnnotationElement(Name.class, "com.example.HelloWorld"));
     eventAnnotations.add(new AnnotationElement(Label.class, "Hello World"));
     eventAnnotations.add(new AnnotationElement(Description.class, "Helps programmer getting started"));
     eventAnnotations.add(new AnnotationElement(Category.class, category));

     EventFactory f = EventFactory.create(eventAnnotations, fields);

     Event event = f.newEvent();
     event.set(0, "hello, world!");
     event.set(1, 4711);
     event.commit();
}
 

public static void main(String[] args) throws Exception {
    // Create an unregistered event
    List<AnnotationElement> annotations = new ArrayList<>();
    annotations.add(new AnnotationElement(Registered.class, false));
    EventFactory factory = EventFactory.create(annotations, Collections.emptyList());

    try {
        factory.getEventType();
        Asserts.fail("Should not be able to get event type from an unregistered event");
    } catch(IllegalStateException ise) {
        // OK as expected
    }

    // Now, register the event
    factory.register();
    EventType eventType = factory.getEventType();
    verifyRegistered(factory.getEventType());


    // Now, unregister the event
    factory.unregister();

    verifyUnregistered(eventType);

    // Create a registered event
    factory = EventFactory.create(Collections.emptyList(), Collections.emptyList());

    eventType = factory.getEventType();
    Asserts.assertNotNull(eventType);

    verifyRegistered(eventType);

}
 

public static void main(String[] args) throws Exception {
    // Create an unregistered event
    List<AnnotationElement> annotations = new ArrayList<>();
    annotations.add(new AnnotationElement(Registered.class, false));
    EventFactory factory = EventFactory.create(annotations, Collections.emptyList());

    try {
        factory.getEventType();
        Asserts.fail("Should not be able to get event type from an unregistered event");
    } catch(IllegalStateException ise) {
        // OK as expected
    }

    // Now, register the event
    factory.register();
    EventType eventType = factory.getEventType();
    verifyRegistered(factory.getEventType());


    // Now, unregister the event
    factory.unregister();

    verifyUnregistered(eventType);

    // Create a registered event
    factory = EventFactory.create(Collections.emptyList(), Collections.emptyList());

    eventType = factory.getEventType();
    Asserts.assertNotNull(eventType);

    verifyRegistered(eventType);

}
 

public static void testArray() throws Exception {
    List<AnnotationElement> annotations = new ArrayList<>();
    Map<String, Object> values = new HashMap<>();
    values.put("stringArray", new String[] {"zero", "one"});
    values.put("intArray", new int[] {0, 1});
    values.put("longArray", new long[] {0L, 1L});
    values.put("floatArray", new float[] {0.0f, 1.0f});
    values.put("doubleArray", new double[] {0.0, 1.0});
    values.put("booleanArray", new boolean[] {false, true});
    values.put("shortArray", new short[] {(short)0, (short)1});
    values.put("byteArray", new byte[] {(byte)0, (byte)1});
    values.put("charArray", new char[] {'0','1'});

    annotations.add(new AnnotationElement(Array.class, values));
    EventFactory f = EventFactory.create(annotations, Collections.emptyList());
    Array a = f.getEventType().getAnnotation(Array.class);
    if (a == null) {
        throw new Exception("Missing array annotation");
    }
    verifyArrayAnnotation(a);
    System.out.println("Event metadata is correct");
    try (Recording r = new Recording()) {
        r.start();
        Event e = f.newEvent();
        e.commit();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        Events.hasEvents(events);
        RecordedEvent re = events.get(0);
        Array arrayAnnotation = re.getEventType().getAnnotation(Array.class);
        if (arrayAnnotation== null) {
            throw new Exception("Missing array annotation");
        }
        verifyArrayAnnotation(arrayAnnotation);
        System.out.println("Persisted event metadata is correct");
    }
}
 

public static void main(String[] args) throws Throwable {
    Recording r = new Recording();
    r.enable(EVENT_TYPE_SHOULD_COMMIT.getName()).withoutStackTrace();
    r.enable(EVENT_TYPE_SHOULD_NOT_COMMIT.getName()).withoutStackTrace();

    // Commit before start, should not be included
    ef1 = EventFactory.create(EVENT_TYPE_SHOULD_NOT_COMMIT.getAnnotations(), EVENT_TYPE_SHOULD_NOT_COMMIT.getFields());

    Event event1 = ef1.newEvent();

    setEventValues(event1, ef1, EVENT_TYPE_SHOULD_NOT_COMMIT);
    event1.commit();

    r.start();
    // Commit after start, should be included
    ef2 = EventFactory.create(EVENT_TYPE_SHOULD_COMMIT.getAnnotations(),  EVENT_TYPE_SHOULD_COMMIT.getFields());

    Event event2 = ef2.newEvent();
    setEventValues(event2, ef2, EVENT_TYPE_SHOULD_COMMIT);
    event2.commit();

    r.stop();

    RecordingFile es = Events.copyTo(r);
    EventType e1 = findEventType(es.readEventTypes(), EVENT_TYPE_SHOULD_NOT_COMMIT.getName());
    assertEquals(e1, ef1.getEventType());

    EventType e2 = findEventType(es.readEventTypes(), EVENT_TYPE_SHOULD_COMMIT.getName());
    assertEquals(e2, ef2.getEventType());

    verifyEvent(es);
}
 

public static void main(String[] args) throws Throwable {
    Recording r = new Recording();
    r.enable(EVENT_TYPE_SHOULD_COMMIT.getName()).withoutStackTrace();
    r.enable(EVENT_TYPE_SHOULD_NOT_COMMIT.getName()).withoutStackTrace();

    // Commit before start, should not be included
    ef1 = EventFactory.create(EVENT_TYPE_SHOULD_NOT_COMMIT.getAnnotations(), EVENT_TYPE_SHOULD_NOT_COMMIT.getFields());

    Event event1 = ef1.newEvent();

    setEventValues(event1, ef1, EVENT_TYPE_SHOULD_NOT_COMMIT);
    event1.commit();

    r.start();
    // Commit after start, should be included
    ef2 = EventFactory.create(EVENT_TYPE_SHOULD_COMMIT.getAnnotations(),  EVENT_TYPE_SHOULD_COMMIT.getFields());

    Event event2 = ef2.newEvent();
    setEventValues(event2, ef2, EVENT_TYPE_SHOULD_COMMIT);
    event2.commit();

    r.stop();

    RecordingFile es = Events.copyTo(r);
    EventType e1 = findEventType(es.readEventTypes(), EVENT_TYPE_SHOULD_NOT_COMMIT.getName());
    assertEquals(e1, ef1.getEventType());

    EventType e2 = findEventType(es.readEventTypes(), EVENT_TYPE_SHOULD_COMMIT.getName());
    assertEquals(e2, ef2.getEventType());

    verifyEvent(es);
}
 

public static void main(String[] args) throws Exception {
    // Create an unregistered event
    List<AnnotationElement> annotations = new ArrayList<>();
    annotations.add(new AnnotationElement(Registered.class, false));
    EventFactory factory = EventFactory.create(annotations, Collections.emptyList());

    try {
        factory.getEventType();
        Asserts.fail("Should not be able to get event type from an unregistered event");
    } catch(IllegalStateException ise) {
        // OK as expected
    }

    // Now, register the event
    factory.register();
    EventType eventType = factory.getEventType();
    verifyRegistered(factory.getEventType());


    // Now, unregister the event
    factory.unregister();

    verifyUnregistered(eventType);

    // Create a registered event
    factory = EventFactory.create(Collections.emptyList(), Collections.emptyList());

    eventType = factory.getEventType();
    Asserts.assertNotNull(eventType);

    verifyRegistered(eventType);

}
 

public static void testArray() throws Exception {
    List<AnnotationElement> annotations = new ArrayList<>();
    Map<String, Object> values = new HashMap<>();
    values.put("stringArray", new String[] {"zero", "one"});
    values.put("intArray", new int[] {0, 1});
    values.put("longArray", new long[] {0L, 1L});
    values.put("floatArray", new float[] {0.0f, 1.0f});
    values.put("doubleArray", new double[] {0.0, 1.0});
    values.put("booleanArray", new boolean[] {false, true});
    values.put("shortArray", new short[] {(short)0, (short)1});
    values.put("byteArray", new byte[] {(byte)0, (byte)1});
    values.put("charArray", new char[] {'0','1'});

    annotations.add(new AnnotationElement(Array.class, values));
    EventFactory f = EventFactory.create(annotations, Collections.emptyList());
    Array a = f.getEventType().getAnnotation(Array.class);
    if (a == null) {
        throw new Exception("Missing array annotation");
    }
    verifyArrayAnnotation(a);
    System.out.println("Event metadata is correct");
    try (Recording r = new Recording()) {
        r.start();
        Event e = f.newEvent();
        e.commit();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        Events.hasEvents(events);
        RecordedEvent re = events.get(0);
        Array arrayAnnotation = re.getEventType().getAnnotation(Array.class);
        if (arrayAnnotation== null) {
            throw new Exception("Missing array annotation");
        }
        verifyArrayAnnotation(arrayAnnotation);
        System.out.println("Persisted event metadata is correct");
    }
}
 

public static void testECID() throws Exception {
    List<ValueDescriptor> fields = new ArrayList<>();

    List<AnnotationElement> fieldAnnotations = new ArrayList<>();
    fieldAnnotations.add(new AnnotationElement(ECID.class));
    ValueDescriptor ecidField = new ValueDescriptor(String.class, "ecid", fieldAnnotations);
    fields.add(ecidField);

    EventFactory f = EventFactory.create(fieldAnnotations, fields);

    String ecidValue = "131739871298371279812";
    try (Recording r = new Recording()) {
        r.start();
        Event event = f.newEvent();
        event.set(0, ecidValue);
        event.commit();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        Events.hasEvents(events);
        Events.assertField(events.get(0), "ecid").equal(ecidValue);
    }
    EventType type = f.getEventType();
    ECID e = type.getAnnotation(ECID.class);
    if (e == null) {
        throw new Exception("Missing ECID annotation");
    }
}
 

public static void testArray() throws Exception {
    List<AnnotationElement> annotations = new ArrayList<>();
    Map<String, Object> values = new HashMap<>();
    values.put("stringArray", new String[] {"zero", "one"});
    values.put("intArray", new int[] {0, 1});
    values.put("longArray", new long[] {0L, 1L});
    values.put("floatArray", new float[] {0.0f, 1.0f});
    values.put("doubleArray", new double[] {0.0, 1.0});
    values.put("booleanArray", new boolean[] {false, true});
    values.put("shortArray", new short[] {(short)0, (short)1});
    values.put("byteArray", new byte[] {(byte)0, (byte)1});
    values.put("charArray", new char[] {'0','1'});

    annotations.add(new AnnotationElement(Array.class, values));
    EventFactory f = EventFactory.create(annotations, Collections.emptyList());
    Array a = f.getEventType().getAnnotation(Array.class);
    if (a == null) {
        throw new Exception("Missing array annotation");
    }
    verifyArrayAnnotation(a);
    System.out.println("Event metadata is correct");
    try (Recording r = new Recording()) {
        r.start();
        Event e = f.newEvent();
        e.commit();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        Events.hasEvents(events);
        RecordedEvent re = events.get(0);
        Array arrayAnnotation = re.getEventType().getAnnotation(Array.class);
        if (arrayAnnotation== null) {
            throw new Exception("Missing array annotation");
        }
        verifyArrayAnnotation(arrayAnnotation);
        System.out.println("Persisted event metadata is correct");
    }
}
 

public static void main(String[] args) throws Throwable {
    Recording r = new Recording();
    r.enable(EVENT_TYPE_SHOULD_COMMIT.getName()).withoutStackTrace();
    r.enable(EVENT_TYPE_SHOULD_NOT_COMMIT.getName()).withoutStackTrace();

    // Commit before start, should not be included
    ef1 = EventFactory.create(EVENT_TYPE_SHOULD_NOT_COMMIT.getAnnotations(), EVENT_TYPE_SHOULD_NOT_COMMIT.getFields());

    Event event1 = ef1.newEvent();

    setEventValues(event1, ef1, EVENT_TYPE_SHOULD_NOT_COMMIT);
    event1.commit();

    r.start();
    // Commit after start, should be included
    ef2 = EventFactory.create(EVENT_TYPE_SHOULD_COMMIT.getAnnotations(),  EVENT_TYPE_SHOULD_COMMIT.getFields());

    Event event2 = ef2.newEvent();
    setEventValues(event2, ef2, EVENT_TYPE_SHOULD_COMMIT);
    event2.commit();

    r.stop();

    RecordingFile es = Events.copyTo(r);
    EventType e1 = findEventType(es.readEventTypes(), EVENT_TYPE_SHOULD_NOT_COMMIT.getName());
    assertEquals(e1, ef1.getEventType());

    EventType e2 = findEventType(es.readEventTypes(), EVENT_TYPE_SHOULD_COMMIT.getName());
    assertEquals(e2, ef2.getEventType());

    verifyEvent(es);
}
 

public static void main(String[] args) throws Exception {
    EventFactory factory = EventFactory.create(Collections.emptyList(), Collections.emptyList());

    EventType eventType = factory.getEventType();
    Asserts.assertNotNull(eventType);

    // Now, register the event
    factory.register();

    verifyRegistered(eventType);

    // Now, register the event again
    factory.register();

    verifyRegistered(eventType);
}
 

public static void main(String... args) throws Exception {
    final String name = "MyLargeJavaEvent64k"; // name of synthetically generated event
    final String fieldNamePrefix = "myfield";
    final int numberOfFields = 8; // 8*8k = ~64k event size
    final Map<String, Object> eventMap = new HashMap<>();
    final int numberOfThreads = 100; // 50 threads will run the test
    final int numberOfEventsPerThread = 50; // each thread will generate 50 events

    List<ValueDescriptor> fields = new ArrayList<>();
    for (int i = 0; i < numberOfFields; ++i) {
        String fieldName = fieldNamePrefix + i;
        eventMap.put(fieldName, largeString());
        fields.add(new ValueDescriptor(String.class, fieldName));
    }

    EventTypePrototype prototype = new EventTypePrototype(name,Collections.emptyList(),  fields);

    EventFactory ef = EventFactory.create(prototype.getAnnotations(), prototype.getFields());

    Recording r = new Recording();
    r.enable(prototype.getName()).withThreshold(Duration.ofNanos(0)).withoutStackTrace();
    r.start();

    Thread.UncaughtExceptionHandler eh = (t, e) -> TestLargeJavaEvent64k.setError();

    Stressor.execute(numberOfThreads, eh, () -> {
        for (int n = 0; n < numberOfEventsPerThread; ++n) {
            try {
                Event event = ef.newEvent();
                setEventValues(event, ef, prototype, eventMap);
                event.commit();
                Thread.sleep(1);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
    });
    r.stop();
    try {
        if (hasError()) {
            throw new RuntimeException("One (or several) of the threads had an exception/error, test failed");
        }
        verifyEvents(r, numberOfThreads, numberOfEventsPerThread, eventMap);
    } finally {
        r.close();
    }
}
 

public static void main(String... args) throws Exception {
    final String name = "MyLargeJavaEvent512k"; // name of synthetically generated event
    final String fieldNamePrefix = "myfield";
    final int numberOfFields = 64; // 64*8k = 512k event size
    final Map<String, Object> eventMap = new HashMap<>();
    final int numberOfThreads = 10; // 10 threads will run the test
    final int numberOfEventsPerThread = 50; // each thread will generate 50 events

    List<ValueDescriptor> fields = new ArrayList<>();
    for (int i = 0; i < numberOfFields; ++i) {
        String fieldName = fieldNamePrefix + i;
        eventMap.put(fieldName, largeString());
        fields.add(new ValueDescriptor(String.class, fieldName));
    }

    EventTypePrototype prototype = new EventTypePrototype(name,Collections.emptyList(),  fields);

    EventFactory ef = EventFactory.create(prototype.getAnnotations(), prototype.getFields());

    Recording r = new Recording();
    r.enable(prototype.getName()).withThreshold(Duration.ofNanos(0)).withoutStackTrace();
    r.start();

    Thread.UncaughtExceptionHandler eh = (t, e) -> TestLargeJavaEvent512k.setError();

    Stressor.execute(numberOfThreads, eh, () -> {
        for (int n = 0; n < numberOfEventsPerThread; ++n) {
            try {
                Event event = ef.newEvent();
                setEventValues(event, ef, prototype, eventMap);
                event.commit();
                Thread.sleep(1);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
    });
    r.stop();
    try {
        if (hasError()) {
            throw new RuntimeException("One (or several) of the threads had an exception/error, test failed");
        }
        verifyEvents(r, numberOfThreads, numberOfEventsPerThread, eventMap);
    } finally {
        r.close();
    }
}
 

public static void main(String[] args) throws Exception {
    EventFactory factory = EventFactory.create(Collections.emptyList(), Collections.emptyList());

    EventType eventType = factory.getEventType();
    Asserts.assertNotNull(eventType);

    // Now, register the event
    factory.register();

    verifyRegistered(eventType);

    // Now, register the event again
    factory.register();

    verifyRegistered(eventType);
}
 

public static void main(String... args) throws Exception {
    final String name = "MyLargeJavaEvent64k"; // name of synthetically generated event
    final String fieldNamePrefix = "myfield";
    final int numberOfFields = 8; // 8*8k = ~64k event size
    final Map<String, Object> eventMap = new HashMap<>();
    final int numberOfThreads = 100; // 50 threads will run the test
    final int numberOfEventsPerThread = 50; // each thread will generate 50 events

    List<ValueDescriptor> fields = new ArrayList<>();
    for (int i = 0; i < numberOfFields; ++i) {
        String fieldName = fieldNamePrefix + i;
        eventMap.put(fieldName, largeString());
        fields.add(new ValueDescriptor(String.class, fieldName));
    }

    EventTypePrototype prototype = new EventTypePrototype(name,Collections.emptyList(),  fields);

    EventFactory ef = EventFactory.create(prototype.getAnnotations(), prototype.getFields());

    Recording r = new Recording();
    r.enable(prototype.getName()).withThreshold(Duration.ofNanos(0)).withoutStackTrace();
    r.start();

    Thread.UncaughtExceptionHandler eh = (t, e) -> TestLargeJavaEvent64k.setError();

    Stressor.execute(numberOfThreads, eh, () -> {
        for (int n = 0; n < numberOfEventsPerThread; ++n) {
            try {
                Event event = ef.newEvent();
                setEventValues(event, ef, prototype, eventMap);
                event.commit();
                Thread.sleep(1);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
    });
    r.stop();
    try {
        if (hasError()) {
            throw new RuntimeException("One (or several) of the threads had an exception/error, test failed");
        }
        verifyEvents(r, numberOfThreads, numberOfEventsPerThread, eventMap);
    } finally {
        r.close();
    }
}
 

public static void main(String[] args) throws Exception {
    EventFactory factory = EventFactory.create(Collections.emptyList(), Collections.emptyList());

    EventType eventType = factory.getEventType();
    Asserts.assertNotNull(eventType);

    // Now, register the event
    factory.register();

    verifyRegistered(eventType);

    // Now, register the event again
    factory.register();

    verifyRegistered(eventType);
}
 

public static void main(String... args) throws Exception {
    final String name = "MyLargeJavaEvent512k"; // name of synthetically generated event
    final String fieldNamePrefix = "myfield";
    final int numberOfFields = 64; // 64*8k = 512k event size
    final Map<String, Object> eventMap = new HashMap<>();
    final int numberOfThreads = 10; // 10 threads will run the test
    final int numberOfEventsPerThread = 50; // each thread will generate 50 events

    List<ValueDescriptor> fields = new ArrayList<>();
    for (int i = 0; i < numberOfFields; ++i) {
        String fieldName = fieldNamePrefix + i;
        eventMap.put(fieldName, largeString());
        fields.add(new ValueDescriptor(String.class, fieldName));
    }

    EventTypePrototype prototype = new EventTypePrototype(name,Collections.emptyList(),  fields);

    EventFactory ef = EventFactory.create(prototype.getAnnotations(), prototype.getFields());

    Recording r = new Recording();
    r.enable(prototype.getName()).withThreshold(Duration.ofNanos(0)).withoutStackTrace();
    r.start();

    Thread.UncaughtExceptionHandler eh = (t, e) -> TestLargeJavaEvent512k.setError();

    Stressor.execute(numberOfThreads, eh, () -> {
        for (int n = 0; n < numberOfEventsPerThread; ++n) {
            try {
                Event event = ef.newEvent();
                setEventValues(event, ef, prototype, eventMap);
                event.commit();
                Thread.sleep(1);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
    });
    r.stop();
    try {
        if (hasError()) {
            throw new RuntimeException("One (or several) of the threads had an exception/error, test failed");
        }
        verifyEvents(r, numberOfThreads, numberOfEventsPerThread, eventMap);
    } finally {
        r.close();
    }
}