Payment Service
This service is responsible to process credit card payments for orders. It will return an error if the credit card is invalid or the payment can not be processed.
Initializing OpenTelemetry
It is recommended to require Node.js app using an initializer file that
initializes the SDK and auto-instrumentation. When initializing the
OpenTelemetry Node.js SDK in that module, you optionally specify which
auto-instrumentation libraries to leverage, or make use of the
getNodeAutoInstrumentations() function which includes most popular frameworks.
The below example of an initializer file (opentelemetry.js) contains all code
required to initialize the SDK and auto-instrumentation based on standard
OpenTelemetry environment variables for OTLP export, resource attributes, and
service name. It then requires your app at ./index.js to start it up once
the SDK is initialized.
const opentelemetry = require('@opentelemetry/sdk-node');
const {
getNodeAutoInstrumentations,
} = require('@opentelemetry/auto-instrumentations-node');
const {
OTLPTraceExporter,
} = require('@opentelemetry/exporter-trace-otlp-grpc');
const {
OTLPMetricExporter,
} = require('@opentelemetry/exporter-metrics-otlp-grpc');
const { PeriodicExportingMetricReader } = require('@opentelemetry/sdk-metrics');
const {
alibabaCloudEcsDetector,
} = require('@opentelemetry/resource-detector-alibaba-cloud');
const {
awsEc2Detector,
awsEksDetector,
} = require('@opentelemetry/resource-detector-aws');
const {
containerDetector,
} = require('@opentelemetry/resource-detector-container');
const { gcpDetector } = require('@opentelemetry/resource-detector-gcp');
const {
envDetector,
hostDetector,
osDetector,
processDetector,
} = require('@opentelemetry/resources');
const sdk = new opentelemetry.NodeSDK({
traceExporter: new OTLPTraceExporter(),
instrumentations: [
getNodeAutoInstrumentations({
// only instrument fs if it is part of another trace
'@opentelemetry/instrumentation-fs': {
requireParentSpan: true,
},
}),
],
metricReader: new PeriodicExportingMetricReader({
exporter: new OTLPMetricExporter(),
}),
resourceDetectors: [
containerDetector,
envDetector,
hostDetector,
osDetector,
processDetector,
alibabaCloudEcsDetector,
awsEksDetector,
awsEc2Detector,
gcpDetector,
],
});
sdk.start();
You can then use opentelemetry.js to start your app. This can be done in the
ENTRYPOINT command for the service’s Dockerfile.
ENTRYPOINT [ "node", "./opentelemetry.js" ]
Traces
Add attributes to auto-instrumented spans
Within the execution of auto-instrumented code you can get current span from context.
const span = opentelemetry.trace.getActiveSpan();
Adding attributes to a span is accomplished using setAttributes on the span
object. In the chargeServiceHandler function an attributes is added to the
span as an anonymous object (map) for the attribute key/values pair.
span.setAttributes({
'app.payment.amount': parseFloat(`${amount.units}.${amount.nanos}`),
});
Span Exceptions and status
You can use the span object’s recordException function to create a span event
with the full stack trace of a handled error. When recording an exception also
be sure to set the span’s status accordingly. You can see this in the
chargeServiceHandler function
span.recordException(err);
span.setStatus({ code: opentelemetry.SpanStatusCode.ERROR });
Metrics
Creating Meters and Instruments
Meters can be created using the @opentelemetry/api-metrics package. You can
create meters as seen below, and then use the created meter to create
instruments.
const { metrics } = require('@opentelemetry/api-metrics');
const meter = metrics.getMeter('paymentservice');
const transactionsCounter = meter.createCounter('app.payment.transactions');
Meters and Instruments are supposed to stick around. This means you should get a Meter or an Instrument once , and then re-use it as needed, if possible.
Logs
TBD
Baggage
OpenTelemetry Baggage is leveraged in this service to check if the request is
synthetic (from the load generator). Synthetic requests will not be charged,
which is indicated with a span attribute. The charge.js file which does the
actual payment processing, has logic to check the baggage.
// check baggage for synthetic_request=true, and add charged attribute accordingly
const baggage = propagation.getBaggage(context.active());
if (
baggage &&
baggage.getEntry('synthetic_request') &&
baggage.getEntry('synthetic_request').value == 'true'
) {
span.setAttribute('app.payment.charged', false);
} else {
span.setAttribute('app.payment.charged', true);
}