Extensions

OpenCore/Probes
JXInsight/OpenCore Probes technology is specifically designed to run in the most demanding of production environments. By default the metering runtime is configured to run in a bare metal mode with very little enabled other than the most necessary extension providers, meters and metrics. Customers have complete control over the degree of measurement and collection performed by instrumentation added into an application either dynamically at runtime or during release build time.

With over 50 built-in optional metering extensions that can be enabled and configured using a single simple config file, JXInsight/OpenCore Probes technology is the most comprehensive software performance measurement, analysis, monitoring and management solution ever built. It is extremely fast and it can be deployed as lean and lightweight as need be with complete overhead control.

Our metering technology has been used to assist companies around the world for the last 5 years in profiling, protecting, policing, prioritizing, predicting, even on-demand provisioning, applications and platforms in environments in which all other technologies and solutions have failed them. We have designed this technology to have very few limits because we use the technology ourselves in very stressful time pressured engagements that demand immediate accurate identification of underlying performance issues in large and very complex applications and systems where the ratio of signal to noise is so significant that it renders other approaches and experts helpless. Below you will find a listing of some of the many innovative extensions we have added to the runtime based on such work. Each one in their own right extremely productive, powerful, and adaptable.

Note: A number of the metering extensions listed below have been described and used in our 10 part performance analysis case study of the Scala compiler.

Security
Provides fine-grained class access control to sensitive runtime operations within the Probes Open API based on the standard Java security manager and permission framework.

Plugin
Provides an extension point with lifecycle method callbacks for creating plug-ins which can apply various operations, such as registration of an event listener or a resource, to metering contexts on initial creation.

Strategy
Dynamically enabled metering of a firing probe based on the voting of one or more strategies: hotspot, frequency, interval, delay, warmup, burst, sample, random, exclude, include, busy thread, busy, high memory, checkpoint, initial, dynamic.

EntryPoint
Dynamically enables metering on a per thread basis when one or more fully or partially qualified named probes become active on the probe stack.

ExitPoint
Disables metering of a thread’s execution (call) stack at the first “exitpoint” labeled probe and then re-enables metering following the completion of the same probe.

TraceDepth
Limits metering to a particular instrumented call (stack) depth range.

TierPoint
Dynamically limits metering to execution points at the boundaries of user defined tiers based on probe name groups.

CallPoint
Only meters firing probes labeled as callpoints or the immediate direct child firing probes of a callpoint probe.

Outline
Dynamically enables metering of probes which represent root or leaf call(er|ee) tree nodes.

Kinline
Dynamically disables the metering of (callee) probes called within the immediate scope of another metered (caller) probe sharing the same probe name (parent) prefix.

NonRecursive
Only meters a firing probe if there is not already a same named probe active on top of the thread stack (on the probe firing stack).

NonReentrant
Only meters a firing probe if there is not already a same named probe currently firing within the thread (on the probe firing stack).

Concurrent
Only meters a firing probe if one or more probes of the same name are firing (though not necessarily metered) in other threads.

Dynamic
A condition based metering extension that offers both coarse grain and fine grain dynamic control over which probes are metered based on enablement flags set at the process, thread, process/group, and thread/group levels.

TracePoint
Enables or disables the metering of all firing probes including nested ones based on a specified sampling frequency.

TracePath
Operates very similar to the hotspot strategy but instead of dynamically determining whether a firing probe is metered based on the probe’s metering profile it uses the metering profile of the current probe path.

TracePermit
Limits the degree of concurrent metering determined at the top most traced probe point and applied to all nested firing probes.

TraceCycle
Dynamically disables the metering of probes nested within the metering window of repeating probe (call) sequence on the probe stack

AutoTune
Automatically increments a hotspot like threshold based on the continuous monitoring and evaluation of a select few probes marked as autotune monitors.

Budget
Dynamically manages the metering overhead by way of a fixed unit cost for each metered probe and a overhead percentage limit.

Inline
Dynamically disables the metering of probes with a metering inherent minimum that is below a specific threshold and which is called directly within the metering scope of another probe that also is below the same threshold

CallPrune
Dynamically disables metering of (callee) probes having a metering total that is X% less than the meter reading total for its enclosing parent (caller) probe

Interceptor
Provides an extension point for interceptors which can be used to dynamically control (filter) metering as well as the metered execution itself via delayed callback completion

QoS
Offers the ability to define resource pools and resource consumers for the purpose of resource (reservation) management.

Quota
Follows the meter consumption of a request, injecting pauses at metering points once running meter total has reached one or more thresholds.

Assert
Throws a java.lang.AssertionError in the event that a metered probe exceeds a threshold specified for one or more included meters.

Logging
Logs the execution of probes exceeding a particular threshold defined on a per log level basis.

Management
Enables the remote management and monitoring of the probes metering model and runtime by other JMX enabled management products.

Metrics
Creates and registers metering and metering groups with the metrics runtime

Swatch
Offers the ability to measure (in development & benchmarking) the performance of calls & paths with sub-microsecond latency.

CallCount
Creates and updates a counter metric named on the beginning of a probe.

CallGauge
Creates and updates a gauge type metric on the beginning of a probe and decremented on ending of a probe.

CallPath
Creates and updates a counter metric accumulating the metering path consumption from the point of entry into a root caller (probe) through to entry into the leaf callee (probe).

CallTrait
Creates and updates counter metrics on the matching of behavioral (metering) trait patterns for a particular top level (call) probes.

Console
Allows a management console to connect to a metered process and collect a metering model snapshot.

UDR
Creates and dispatches usage detail records (UDR), similiar to teleco call detail records, to an external persistence store.

Watch
Evaluates named conditions, watches, on completion of a metered probe and its associated metering (group + meter) update. For each positive evaluation of a watch condition a counter local to and accessible from the associated metering is incremented.

Statistic
Reports statistical measures for metering over a fixed sized & time constrained rolling metering window.

Transaction
Records metering change sets for particular transaction point probes that exceed one or more metering thresholds.

Billing
Maintains a recent metering history for each thread.

Charge
Provide a meter breakdown analysis of non-inherent metering for a charged probe by charging probes.

Tracking
Provides a breakdown of a probe group’s metering within the context of direct and indirect firing probes by the same executing thread.

Quantization
Performs quantization of fired and metered probe meter readings.

Current
Abstracts an entry processing point within a runtime serving (http) requests, executing (runnable) tasks, invoking (rpc) calls, dispatching (actor) messages, running (grid) jobs, etc.

Stack
Enables read-only inspection (and printing) of the current “metered” probe stack for a thread.

Queue
Provides runtime analysis of concurrent metered thread workload behavior at particular service probe points and associated metering groups.

Event
Dispatches metering life-cycle events to registered probe event listeners.

Apdex
Creates 3 counters representing the standard performance zones within the Apdex specification per fired & metering named probe.

Baseline
Creates a counter per probe per meter representing the number of times an adapative metering baseline is exceeded.

Recorder
Records all metered probe firings to a binary log recording file that can be played back in a simulated metering environment.

Simz
Provides the the client side feed extension for the JXInsight/Simz add-on.

Tag
Maps tags associated within firing probes to global and thread level metering groups.

Service
Enables a service meter, reflecting the level of concurrent resource usage and metering, to be included in the resource metering model for each global resource meter.

OpenCore/Metrics
An Open API that allows developers to extend the metric monitoring capabilities of JXInsight’s OpenCore to custom components and frameworks. It samples registered measures at fixed intervals recording various statistics and maintaining a limited sample history in memory as well as extending base metrics and integration with other monitoring systems.

Security
Provides fine-grained class access control to sensitive runtime operations within the Metrics Open API based on the standard Java security manager and permission framework.

Plugin
Provides an extension point with lifecycle method callbacks for creating plug-ins which can apply various operations such as adding an event listener or registering one or more metric measures.

Jitter
Creates and updates metrics tracking JVM execution jitter frequency and time.

Logging
Logs a record for each metric sampled within a collection.

JStat
Registers a corresponding named jvmstat counter for each metric registered

Management
Registers metrics with the local JMX MBeanServer.

Console
Allows a management console to connect to a monitored process and collect a metric model snapshot.

Statistic
Publishes and maintains statistics associated with registered metrics sampled.

Delta
Registers an associated delta metric with the metrics runtime for each metric of type counter registered.

Mark
Creates an associated mark metric of type gauge for each counter type metric.

Event
Dispatches metric sampling life-cycle events to registered metric event listeners.

Tag
Creates an associated named tag metric for each registered metric.

Watch
Registers a conditional watch metric with the metrics runtime for each metric associated with a watch.