DatastoreShim

The agent associated with this shim.

The logger for this shim.

The transaction tracer in use by the agent for the shim.

An enumeration of well-known datastores so that new instrumentations can use the same names we already use for first-party instrumentation.

Each of these values is also exposed directly on the DatastoreShim class as static members.

Pre-defined query parsers for well-known languages.

Each of these values is also exposed directly on the DatastoreShim class as static members.

Binds a function to the async context manager with the passed in context.

• applyContext({ func, context , full, boundThis, args, inContextCB })

Binds a function to the async context manager with the segment passed in. It'll pull the active transaction from the context manager.

• applySegment(func, segment, full, context, args[, inContextCB])

Like Shim#toArray, but converts arguments to an array.

This is the preferred function, when used with .apply, for converting the arguments object into an actual Array as it will not cause deopts.

Assigns id to shim instance. If shimName is present it will reuse an id otherwise it'll create a unique id.

Assigns the shim id and original on the wrapped item. TODO: Once all wrapping is converted to proxies, we won't need to set this property as the trap on 'get' will return the original for symbols.original. For now, we have to prevent setting this on original.

Replaces the callback in an arguments array with one that has been bound to the given segment.

• bindCallbackSegment(spec, args, cbIdx [, segment])
• bindCallbackSegment(spec, obj, property [, segment])

Binds the execution of a function to a context instance. Similar to bindSegment but this requires passing in of an instance of Context.

Binds the given segment to the completion of the Promise. Updates segment timing and resets opaque state.

Wraps the callback in an arguments array with one that is bound to a segment.

• bindRowCallbackSegment(args, cbIdx [, parentSegment])

Binds the execution of a function to a single segment.

• bindSegment(nodule , property [, segment [, full]])
• bindSegment(func [, segment [, full]])

If called with a nodule and a property, the wrapped property will be put back on the nodule. Otherwise, the wrapped function is just returned.

Normalizes and adds datastore instance attributes to the current segment.

If the current segment was not created by this shim then no action is taken.

Copies the given parameters onto the segment, respecting the current agent configuration.

Creates a new segment.

• createSegment(opts)
• createSegment(name [, recorder] [, parent])

Adds several properties to the given object.

Defines a read-only property on the given object.

Entry point for executing a spec.

Retrieves the segment associated with the given object, or the currently active segment if no object is given.

• getActiveSegment([obj])

An active segment is one whose transaction is still active (e.g. has not ended yet).

Determine the name of an object.

Retrieves the original method for a wrapped function.

• getOriginal(nodule, property)
• getOriginal(func)

Retrieves the value of symbols.original on the wrapped function. Unlike getOriginal this just looks in the direct wrapped function

Retrieves the segment associated with the given object, or the current segment if no object is given.

• getSegment([obj])

Executes the given callback when the promise is finalized, whether it is resolved or rejected.

Determines if the given object exists and is an array.

Determines if function is an async function. Note it does not test if the return value of function is a promise or async function

Determines if the given object is a boolean literal.

Determines if the given object exists and is a function.

Determines if the given value is null.

Determines if the given object is a number literal.

Determines if the given object is an Object.

Determines if the given object is a promise instance.

Determines if the given object exists and is a string.

Determines if the specified function or property exists and is wrapped.

• isWrapped(nodule, property)
• isWrapped(func)

Ensures the given index is a valid index inside the array.

A negative index value is converted to a positive one by adding it to the array length before checking it.

Wraps a function such that it will only be executed once.

Parses the given query to extract information for any metrics that will be created.

NOTE: Calling this method before DatastoreShim#setDatastore will result in an exception.

This method is no longer in use. It still exists to avoid crashing applications. The logic of this method has been integrated into finalizing a web transaction.

Proxies all set/get actions for each given property on dest onto source.

Wraps a function with segment creation and binding.

• record(nodule, properties, recordNamer)
• record(func, recordNamer)

This is shorthand for calling Shim#wrap and manually creating a segment.

Just like DatastoreShim#recordQuery, but with a batch suffix for the recorded metric.

• recordBatchQuery(nodule, properties, querySpec)
• recordBatchQuery(func, querySpec)

The resulting wrapped methods will record their actions using the datastore STATEMENT metric with a /batch suffix.

NOTE: Calling this method before DatastoreShim#setDatastore will result in an exception.

Wraps the given properties as datastore operations that should be recorded.

• recordOperation(nodule, properties, opSpec)
• recordOperation(func, opSpec)

The resulting wrapped methods will record their actions using the datastore OPERATION metric.

NOTE: Calling this method before DatastoreShim#setDatastore will result in an exception.

Wraps the given properties as datastore query that should be recorded.

• recordQuery(nodule, properties, querySpec)
• recordQuery(func, querySpec)

The resulting wrapped methods will record their actions using the datastore STATEMENT metric.

NOTE: Calling this method before DatastoreShim#setDatastore will result in an exception.

Explicitly sets the active segment to the one passed in. This method should only be used if there is no function to tie a segment's timing to.

• setActiveSegment(segment)

Sets the vendor the module implements.

This is used to determine the names for metrics and segments. If a string is passed, metric names will be generated using that name.

This method MUST be called to use any methods that generate segments or metrics.

Performs a shallow copy of each property from defaults only if obj does not already have that property, or the value of the key on obj is null.

Sets the query parser used by this shim instance.

Loads a node module from the instrumented library's own root directory.

Associates a segment with the given object.

• storeSegment(obj [, segment])

If no segment is provided, the currently active segment is used.

Converts an array-like object into an array.

Unwraps one item, revealing the underlying value. If item is wrapped multiple times, the unwrap will not occur as we cannot safely unwrap.

• unwrap(nodule, property)
• unwrap(func)

If called with a nodule and properties, the unwrapped value will be put back on the nodule. Otherwise, the unwrapped function is just returned.

Executes the provided spec on one or more objects.

• wrap(nodule, properties, spec [, args])
• wrap(func, spec [, args])

When called with a nodule and one or more properties, the spec will be executed on each property listed and the return value put back on the nodule.

When called with just a function, the spec will be executed on the function and the return value of the spec simply passed back.

The wrapped version will have the same prototype as the original method.

Wraps a class constructor using a subclass with pre- and post-construction hooks.

• wrapClass(nodule, properties, spec [, args])
• wrapClass(func, spec [, args])

Wraps the actual module being instrumented to change what require returns.

• wrapExport(nodule, spec)

Executes the provided spec with the return value of the given properties.

• wrapReturn(nodule, properties, spec [, args])
• wrapReturn(func, spec [, args])

If the wrapper is executed with new then the wrapped function will also be called with new. This feature should only be used with factory methods disguised as classes. Normally Shim#wrapClass should be used to wrap constructors instead.