- System requirements
- Profiler architecture
- Profiler installation
- Uninstall profiler
- Running the profiler
- Profiler activation
- Welcome screen
- Start profiling
- Profiling overhead
- Snapshots
- Solving performance problems
- CPU profiling
- Thread profiling
- Virtual threads support
- Object allocation profiling
- Memory profiling
- Monitor profiling
- Exception profiling
- Telemetry
- Probes: monitor events of various kinds
- Events in user interface
- Event inspections
- Built-in probes
- Probe classes
- Monitoring method invocation events
- Probe class annotation @MethodPattern
- Callback onEnter()
- Callback onReturn()
- Callback onExit()
- Callbacks onUncaughtException() and onUncaughtExceptionExt()
- Parameter annotation @Param
- Parameter annotation @Params
- Parameter annotation @This
- Parameter annotation @ClassRef
- Parameter annotation @MethodName
- Parameter annotation @MethodTimeMs
- Parameter annotation @MethodTimeNs
- Parameter annotation @MethodParameterTypes
- Parameter annotation @MethodSignature
- Parameter annotation @OnEnterResult
- Parameter annotation @ReturnValue
- Parameter annotation @ThrownException
- Probe application rules
- Data storage
- Tables, rows, columns
- Lasting events and point events
- Table API
- Scalability
- Inspections: automatic recognition of typical problems
- Automatically trigger actions on event
- Automatic deobfuscation
- Summary
- Filters
- Profiler command line
- Export of profiling results to external formats
- Profiler Java API
- Profiler HTTP API
- Settings
- Troubleshooting and FAQ
Lasting events and point events
Event kinds
Each table row contains information on some event.
There are two kinds of events:
- Lasting event: this is something which lasts in time. At some point in time it starts, and at a later point in time it ends. The lasting event duration can be measured as end time minus start time.
- Point event: this is some "fact" which just happens at some point of time. The concept of duration is not applicable for the point events.
Which kind to use?
Whether particular event is lasting event or point event, depends on your tasks.
For example, you may think of method Foo.bar()
execution as of a lasting event,
which starts when the method enters and ends when the method exits,
if you are interested to know how long the method execution takes,
or to discover other events which happen while Foo.bar() is running,
e.g. what kind of I/O it performs, whether it accesses database or other resources etc.
In case you are only interested in Foo.bar() invocations as in a fact,
you may think of them as of point events.
Technical detail
On table creation, you decide which kind of events the table is intended for, specifying appropriate parameters of the table object constructor.
So, each table can store either of the event kinds.
A lasting event starts when table row is created with Table.createRow()
and ends when the row is closed with Table.closeRow().
Table.closeRow() must not be used for tables with point events.
Thread, stack trace and/or times are recorded for all events on row creation, and also on row closing for lasting events.
For lasting events recorded as some table rows it is possible to find rows in other tables which correspond to events which happened during the lasting event. For example, if processing of JSP pages is recorded as lasting events in some table, and database access events are recorded in another table, it will be possible to learn which SQL activities happen during particular JSP page processing.