@opentelemetry/instrumentation
Version:
Base class for node which OpenTelemetry instrumentation modules extend
141 lines • 4.86 kB
JavaScript
/*
* Copyright The OpenTelemetry Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { diag, metrics, trace, } from '@opentelemetry/api';
import { logs } from '@opentelemetry/api-logs';
import * as shimmer from 'shimmer';
/**
* Base abstract internal class for instrumenting node and web plugins
*/
export class InstrumentationAbstract {
instrumentationName;
instrumentationVersion;
_config = {};
_tracer;
_meter;
_logger;
_diag;
constructor(instrumentationName, instrumentationVersion, config) {
this.instrumentationName = instrumentationName;
this.instrumentationVersion = instrumentationVersion;
this.setConfig(config);
this._diag = diag.createComponentLogger({
namespace: instrumentationName,
});
this._tracer = trace.getTracer(instrumentationName, instrumentationVersion);
this._meter = metrics.getMeter(instrumentationName, instrumentationVersion);
this._logger = logs.getLogger(instrumentationName, instrumentationVersion);
this._updateMetricInstruments();
}
/* Api to wrap instrumented method */
_wrap = shimmer.wrap;
/* Api to unwrap instrumented methods */
_unwrap = shimmer.unwrap;
/* Api to mass wrap instrumented method */
_massWrap = shimmer.massWrap;
/* Api to mass unwrap instrumented methods */
_massUnwrap = shimmer.massUnwrap;
/* Returns meter */
get meter() {
return this._meter;
}
/**
* Sets MeterProvider to this plugin
* @param meterProvider
*/
setMeterProvider(meterProvider) {
this._meter = meterProvider.getMeter(this.instrumentationName, this.instrumentationVersion);
this._updateMetricInstruments();
}
/* Returns logger */
get logger() {
return this._logger;
}
/**
* Sets LoggerProvider to this plugin
* @param loggerProvider
*/
setLoggerProvider(loggerProvider) {
this._logger = loggerProvider.getLogger(this.instrumentationName, this.instrumentationVersion);
}
/**
* @experimental
*
* Get module definitions defined by {@link init}.
* This can be used for experimental compile-time instrumentation.
*
* @returns an array of {@link InstrumentationModuleDefinition}
*/
getModuleDefinitions() {
const initResult = this.init() ?? [];
if (!Array.isArray(initResult)) {
return [initResult];
}
return initResult;
}
/**
* Sets the new metric instruments with the current Meter.
*/
_updateMetricInstruments() {
return;
}
/* Returns InstrumentationConfig */
getConfig() {
return this._config;
}
/**
* Sets InstrumentationConfig to this plugin
* @param config
*/
setConfig(config) {
// copy config first level properties to ensure they are immutable.
// nested properties are not copied, thus are mutable from the outside.
this._config = {
enabled: true,
...config,
};
}
/**
* Sets TraceProvider to this plugin
* @param tracerProvider
*/
setTracerProvider(tracerProvider) {
this._tracer = tracerProvider.getTracer(this.instrumentationName, this.instrumentationVersion);
}
/* Returns tracer */
get tracer() {
return this._tracer;
}
/**
* Execute span customization hook, if configured, and log any errors.
* Any semantics of the trigger and info are defined by the specific instrumentation.
* @param hookHandler The optional hook handler which the user has configured via instrumentation config
* @param triggerName The name of the trigger for executing the hook for logging purposes
* @param span The span to which the hook should be applied
* @param info The info object to be passed to the hook, with useful data the hook may use
*/
_runSpanCustomizationHook(hookHandler, triggerName, span, info) {
if (!hookHandler) {
return;
}
try {
hookHandler(span, info);
}
catch (e) {
this._diag.error(`Error running span customization hook due to exception in handler`, { triggerName }, e);
}
}
}
//# sourceMappingURL=instrumentation.js.map