+ * This class provides the methods necessary for creating, starting, stopping, + * and destroying recordings. + * + * @since 9 + */ +public final class FlightRecorder { + private static volatile FlightRecorder platformRecorder; + private static volatile boolean initialized; + private final PlatformRecorder internal; + + private FlightRecorder(PlatformRecorder internal) { + this.internal = internal; + } + + /** + * Returns an immutable list of the available recordings. + *
+ * A recording becomes available when it is created. It becomes unavailable when it
+ * is in the {@code CLOSED} state, typically after a call to
+ * {@link Recording#close()}.
+ *
+ * @return a list of recordings, not {@code null}
+ */
+ public List
+ * A snapshot is a synthesized recording in a stopped state. If no data is
+ * available, a recording with size {@code 0} is returned.
+ *
+ * A snapshot provides stable access to data for later operations (for example,
+ * operations to change the interval or to reduce the data size).
+ *
+ * Example,
+ *
+ *
+ * If the event class is already registered, then the invocation of this method is
+ * ignored.
+ *
+ * @param eventClass the event class to register, not {@code null}
+ *
+ * @throws IllegalArgumentException if class is abstract or not a subclass
+ * of {@link Event}
+ * @throws SecurityException if a security manager exists and the caller
+ * does not have {@code FlightRecorderPermission("registerEvent")}
+ */
+ public static void register(Class eventClass) {
+ Objects.requireNonNull(eventClass);
+ if (JVMSupport.isNotAvailable()) {
+ return;
+ }
+ Utils.ensureValidEventSubclass(eventClass);
+ MetadataRepository.getInstance().register(eventClass);
+ }
+
+ /**
+ * Unregisters an event class.
+ *
+ * If the event class is not registered, then the invocation of this method is
+ * ignored.
+ *
+ * @param eventClass the event class to unregistered, not {@code null}
+ * @throws IllegalArgumentException if a class is abstract or not a subclass
+ * of {@link Event}
+ *
+ * @throws SecurityException if a security manager exists and the caller
+ * does not have {@code FlightRecorderPermission("registerEvent")}
+ */
+ public static void unregister(Class eventClass) {
+ Objects.requireNonNull(eventClass);
+ if (JVMSupport.isNotAvailable()) {
+ return;
+ }
+ Utils.ensureValidEventSubclass(eventClass);
+ MetadataRepository.getInstance().unregister(eventClass);
+ }
+
+ /**
+ * Returns the Flight Recorder for the platform.
+ *
+ * @return a Flight Recorder instance, not {@code null}
+ *
+ * @throws IllegalStateException if the platform Flight Recorder couldn't be
+ * created (for example, if the file repository can't be created or
+ * accessed)
+ *
+ * @throws SecurityException if a security manager exists and the caller does
+ * not have {@code FlightRecorderPermission("accessFlightRecorder")}
+ */
+ public static FlightRecorder getFlightRecorder() throws IllegalStateException, SecurityException {
+ synchronized (PlatformRecorder.class) {
+ Utils.checkAccessFlightRecorder();
+ JVMSupport.ensureWithIllegalStateException();
+ if (platformRecorder == null) {
+ try {
+ platformRecorder = new FlightRecorder(new PlatformRecorder());
+ } catch (IllegalStateException ise) {
+ throw ise;
+ } catch (Exception e) {
+ throw new IllegalStateException("Can't create Flight Recorder. " + e.getMessage(), e);
+ }
+ // Must be in synchronized block to prevent instance leaking out
+ // before initialization is done
+ initialized = true;
+ Logger.log(JFR, INFO, "Flight Recorder initialized");
+ Logger.log(JFR, DEBUG, "maxchunksize: " + Options.getMaxChunkSize()+ " bytes");
+ Logger.log(JFR, DEBUG, "memorysize: " + Options.getMemorySize()+ " bytes");
+ Logger.log(JFR, DEBUG, "globalbuffersize: " + Options.getGlobalBufferSize()+ " bytes");
+ Logger.log(JFR, DEBUG, "globalbuffercount: " + Options.getGlobalBufferCount());
+ Logger.log(JFR, DEBUG, "dumppath: " + Options.getDumpPath());
+ Logger.log(JFR, DEBUG, "samplethreads: " + Options.getSampleThreads());
+ Logger.log(JFR, DEBUG, "stackdepth: " + Options.getStackDepth());
+ Logger.log(JFR, DEBUG, "threadbuffersize: " + Options.getThreadBufferSize());
+ Logger.log(JFR, LogLevel.INFO, "Created repository " + Repository.getRepository().getRepositoryPath().toString());
+ PlatformRecorder.notifyRecorderInitialized(platformRecorder);
+ }
+ }
+ return platformRecorder;
+ }
+
+ /**
+ * Adds a callback for a periodic event.
+ *
+ * The implementation of the hook should return as soon as possible, to
+ * avoid blocking other Flight Recorder operations. The hook should emit
+ * one or more events of the specified type. When a hook is added, the
+ * interval at which the call is invoked is configurable using the
+ * {@code "period"} setting.
+ *
+ * @param eventClass the class that the hook should run for, not {@code null}
+ * @param hook the hook, not {@code null}
+ * @throws IllegalArgumentException if a class is not a subclass of
+ * {@link Event}, is abstract, or the hook is already added
+ * @throws IllegalStateException if the event class has the
+ * {@code Registered(false)} annotation and is not registered manually
+ * @throws SecurityException if a security manager exists and the caller
+ * does not have {@code FlightRecorderPermission("registerEvent")}
+ */
+ public static void addPeriodicEvent(Class eventClass, Runnable hook) throws SecurityException {
+ Objects.requireNonNull(eventClass);
+ Objects.requireNonNull(hook);
+ if (JVMSupport.isNotAvailable()) {
+ return;
+ }
+
+ Utils.ensureValidEventSubclass(eventClass);
+ Utils.checkRegisterPermission();
+ AccessControlContext acc = AccessController.getContext();
+ RequestEngine.addHook(acc, EventType.getEventType(eventClass).getPlatformEventType(), hook);
+ }
+
+ /**
+ * Removes a callback hook for a periodic event.
+ *
+ * @param hook the hook to remove, not {@code null}
+ * @return {@code true} if hook is removed, {@code false} otherwise
+ * @throws SecurityException if a security manager exists and the caller
+ * does not have {@code FlightRecorderPermission("registerEvent")}
+ */
+ public static boolean removePeriodicEvent(Runnable hook) throws SecurityException {
+ Objects.requireNonNull(hook);
+ Utils.checkRegisterPermission();
+ if (JVMSupport.isNotAvailable()) {
+ return false;
+ }
+ return RequestEngine.removeHook(hook);
+ }
+
+ /**
+ * Returns an immutable list that contains all currently registered events.
+ *
+ * By default, events are registered when they are first used, typically
+ * when an event object is allocated. To ensure an event is visible early,
+ * registration can be triggered by invoking the
+ * {@link FlightRecorder#register(Class)} method.
+ *
+ * @return list of events, not {@code null}
+ */
+ public List
+ * If Flight Recorder is already initialized when the listener is added, the the method
+ * {@link FlightRecorderListener#recorderInitialized(FlightRecorder)} method is
+ * invoked before returning from this method.
+ *
+ * @param changeListener the listener to add, not {@code null}
+ *
+ * @throws SecurityException if a security manager exists and the caller
+ * does not have
+ * {@code FlightRecorderPermission("accessFlightRecorder")}
+ */
+ public static void addListener(FlightRecorderListener changeListener) {
+ Objects.requireNonNull(changeListener);
+ Utils.checkAccessFlightRecorder();
+ if (JVMSupport.isNotAvailable()) {
+ return;
+ }
+ PlatformRecorder.addListener(changeListener);
+ }
+
+ /**
+ * Removes a recorder listener.
+ *
+ * If the same listener is added multiple times, only one instance is
+ * removed.
+ *
+ * @param changeListener listener to remove, not {@code null}
+ *
+ * @throws SecurityException if a security manager exists and the caller
+ * does not have
+ * {@code FlightRecorderPermission("accessFlightRecorder")}
+ *
+ * @return {@code true}, if the listener could be removed, {@code false}
+ * otherwise
+ */
+ public static boolean removeListener(FlightRecorderListener changeListener) {
+ Objects.requireNonNull(changeListener);
+ Utils.checkAccessFlightRecorder();
+ if (JVMSupport.isNotAvailable()) {
+ return false;
+ }
+
+ return PlatformRecorder.removeListener(changeListener);
+ }
+
+ /**
+ * Returns {@code true} if the Java Virtual Machine (JVM) has Flight Recorder capabilities.
+ *
+ * This method can quickly check whether Flight Recorder can be
+ * initialized, without actually doing the initialization work. The value may
+ * change during runtime and it is not safe to cache it.
+ *
+ * @return {@code true}, if Flight Recorder is available, {@code false}
+ * otherwise
+ *
+ * @see FlightRecorderListener for callback when Flight Recorder is
+ * initialized
+ */
+ public static boolean isAvailable() {
+ if (JVMSupport.isNotAvailable()) {
+ return false;
+ }
+ return JVM.getJVM().isAvailable();
+ }
+
+ /**
+ * Returns {@code true} if Flight Recorder is initialized.
+ *
+ * @return {@code true}, if Flight Recorder is initialized,
+ * {@code false} otherwise
+ *
+ * @see FlightRecorderListener for callback when Flight Recorder is
+ * initialized
+ */
+ public static boolean isInitialized() {
+ return initialized;
+ }
+
+ // package private
+ PlatformRecording newInternalRecording(Map
+ *
+ *
+ * The caller must close the recording when access to the data is no longer
+ * needed.
+ *
+ * @return a snapshot of all available recording data, not {@code null}
+ */
+ public Recording takeSnapshot() {
+ return internal.newSnapshot();
+ }
+
+ /**
+ * Registers an event class.
+ *
+ * try (Recording snapshot = FlightRecorder.getFlightRecorder().takeSnapshot()) {
+ * if (snapshot.getSize() > 0) {
+ * snapshot.setMaxSize(100_000_000);
+ * snapshot.setMaxAge(Duration.ofMinutes(5));
+ * snapshot.dump(Paths.get("snapshot.jfr"));
+ * }
+ * }
+ *
+ *