How to use the opentracing.Tags.ERROR function in opentracing

it('should set error tag for > 3xx status codes', async () => {
      const app = express()
      app.get('/', (req, res) => {
        res.statusCode = 400
        res.send('ok')
      })

      await request(app)
        .get('/')
        .expect(400)
        .end()

      expect(mockSpan.setTag).to.be.calledWith(Tags.HTTP_STATUS_CODE, 400)
      expect(mockSpan.setTag).to.be.calledWith(Tags.ERROR, true)
      expect(mockSpan.finish).to.have.callCount(1)
    })
  })

fragment.once('error', err => {
            this.emit('error', request, err);
            span.addTags({
                [Tags.ERROR]: true,
                [Tags.HTTP_STATUS_CODE]: 500
            });
            span.log({
                message: err.message,
                stack: err.stack
            });
            response.writeHead(500, responseHeaders);
            response.end(INTERNAL_SERVER_ERROR);
            span.finish();
        });
    };

.catch( err => {
            span.setTag(Tags.ERROR, true)
            span.setTag(Tags.HTTP_STATUS_CODE, err.statusCode || 500);
            span.finish();
        });

exports.log = function (level, payload, span = undefined, tagObj = undefined) {
    if (span && tagObj) {
        for (let tag in tagObj) {
            if (Object.prototype.hasOwnProperty.call(tagObj, tag)) {
                span.setTag(tag, tagObj[tag]);
            }
        }
    }
    if (span && level === 'error') {
        span.setTag(Tags.ERROR, true);
    }
    logger.log(level, JSON.stringify(payload));
    if (span) {
        span.log(payload);
    }
};
//# sourceMappingURL=error.utils.js.map

      spans.forEach((span) => span.setTag(Tags.ERROR, true))

setResponseError: function(obj, msg, stack, statusCode) {
        if (process.env.EDGEMICRO_OPENTRACE) {
            try {
                responsespan.setTag(Tags.ERROR, true);
                responsespan.setTag(Tags.HTTP_STATUS_CODE, statusCode);
                responsespan.log({
                    'event': 'error',
                    'error.object': obj,
                    'message': msg,
                    'stack': stack
                });
                responsespan.finish();        
            } catch (err) {}
        }
    },
    endTargetSpan: function(statusCode) {

function responseErrorInterceptor(error: IAxiosOpentracingError) {
  if (error.config) {
    const { span } = error.config;
    try {
      span.setTag(Tags.ERROR, true);
      span.setTag(Tags.HTTP_STATUS_CODE, error.code);
      span.finish();
    } catch (e) {}
  }
  return Promise.reject(error);
}

public onMessageFailed(e: Error, { spans }: IMessage): void {
    const span = spans;
    span.setTag(Tags.ERROR, true);
    span.log(e);
  }
  public onMessageSuccess({ spans }: IMessage): void {

app.get('/', (req, res, next) => next(err))
      app.use((error, req, res, next) => {
        res.statusCode = 500
        res.end()
        next()
      })

      await request(app)
        .get('/')
        .expect(500)
        .end()

      expect(cls.startChildSpan).to.be.calledWith(tracer, instrumentation.OPERATION_NAME, {
        tags: {
          [Tags.ERROR]: true
        }
      })

      expect(mockRootSpan.setTag).to.be.calledWith(Tags.ERROR, true)
      expect(mockChildSpan.log).to.be.calledWith({
        event: 'error',
        'error.object': err,
        message: err.message,
        stack: err.stack
      })
      expect(mockChildSpan.finish).to.have.callCount(1)
    })