mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-23 02:55:13 -04:00
373 lines
12 KiB
JavaScript
373 lines
12 KiB
JavaScript
const SandboxedModule = require("sandboxed-module");
|
|
const bunyan = require("bunyan");
|
|
const chai = require("chai");
|
|
const path = require("path");
|
|
const sinon = require("sinon");
|
|
const sinonChai = require("sinon-chai");
|
|
|
|
chai.use(sinonChai);
|
|
chai.should();
|
|
|
|
const modulePath = path.join(__dirname, "../../logging-manager.js");
|
|
|
|
describe("LoggingManager", function() {
|
|
beforeEach(function() {
|
|
this.start = Date.now();
|
|
this.clock = sinon.useFakeTimers(this.start);
|
|
this.captureException = sinon.stub();
|
|
this.mockBunyanLogger = {
|
|
debug: sinon.stub(),
|
|
error: sinon.stub(),
|
|
fatal: sinon.stub(),
|
|
info: sinon.stub(),
|
|
level: sinon.stub(),
|
|
warn: sinon.stub()
|
|
};
|
|
this.mockRavenClient = {
|
|
captureException: this.captureException,
|
|
once: sinon.stub().yields()
|
|
};
|
|
this.LoggingManager = SandboxedModule.require(modulePath, {
|
|
globals: { console },
|
|
requires: {
|
|
bunyan: (this.Bunyan = {
|
|
createLogger: sinon.stub().returns(this.mockBunyanLogger),
|
|
RingBuffer: bunyan.RingBuffer
|
|
}),
|
|
raven: (this.Raven = {
|
|
Client: sinon.stub().returns(this.mockRavenClient)
|
|
}),
|
|
request: (this.Request = sinon.stub())
|
|
}
|
|
});
|
|
this.loggerName = "test";
|
|
this.logger = this.LoggingManager.initialize(this.loggerName);
|
|
this.logger.initializeErrorReporting("test_dsn");
|
|
});
|
|
|
|
afterEach(function() {
|
|
this.clock.restore();
|
|
});
|
|
|
|
describe("initialize", function() {
|
|
beforeEach(function() {
|
|
this.checkLogLevelStub = sinon.stub(this.LoggingManager, "checkLogLevel");
|
|
this.Bunyan.createLogger.reset();
|
|
});
|
|
|
|
afterEach(function() {
|
|
this.checkLogLevelStub.restore();
|
|
});
|
|
|
|
describe("not in production", function() {
|
|
beforeEach(function() {
|
|
this.logger = this.LoggingManager.initialize(this.loggerName);
|
|
});
|
|
|
|
it("should default to log level debug", function() {
|
|
this.Bunyan.createLogger.firstCall.args[0].streams[0].level.should.equal(
|
|
"debug"
|
|
);
|
|
});
|
|
|
|
it("should not run checkLogLevel", function() {
|
|
this.checkLogLevelStub.should.not.have.been.called;
|
|
});
|
|
});
|
|
|
|
describe("in production", function() {
|
|
beforeEach(function() {
|
|
process.env.NODE_ENV = "production";
|
|
this.logger = this.LoggingManager.initialize(this.loggerName);
|
|
});
|
|
|
|
afterEach(() => delete process.env.NODE_ENV);
|
|
|
|
it("should default to log level warn", function() {
|
|
this.Bunyan.createLogger.firstCall.args[0].streams[0].level.should.equal(
|
|
"warn"
|
|
);
|
|
});
|
|
|
|
it("should run checkLogLevel", function() {
|
|
this.checkLogLevelStub.should.have.been.calledOnce;
|
|
});
|
|
|
|
describe("after 1 minute", () =>
|
|
it("should run checkLogLevel again", function() {
|
|
this.clock.tick(61 * 1000);
|
|
this.checkLogLevelStub.should.have.been.calledTwice;
|
|
}));
|
|
|
|
describe("after 2 minutes", () =>
|
|
it("should run checkLogLevel again", function() {
|
|
this.clock.tick(121 * 1000);
|
|
this.checkLogLevelStub.should.have.been.calledThrice;
|
|
}));
|
|
});
|
|
|
|
describe("when LOG_LEVEL set in env", function() {
|
|
beforeEach(function() {
|
|
process.env.LOG_LEVEL = "trace";
|
|
this.LoggingManager.initialize();
|
|
});
|
|
|
|
afterEach(() => delete process.env.LOG_LEVEL);
|
|
|
|
it("should use custom log level", function() {
|
|
this.Bunyan.createLogger.firstCall.args[0].streams[0].level.should.equal(
|
|
"trace"
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("bunyan logging", function() {
|
|
beforeEach(function() {
|
|
this.logArgs = [{ foo: "bar" }, "foo", "bar"];
|
|
});
|
|
|
|
it("should log debug", function() {
|
|
this.logger.debug(this.logArgs);
|
|
this.mockBunyanLogger.debug.should.have.been.calledWith(this.logArgs);
|
|
});
|
|
|
|
it("should log error", function() {
|
|
this.logger.error(this.logArgs);
|
|
this.mockBunyanLogger.error.should.have.been.calledWith(this.logArgs);
|
|
});
|
|
|
|
it("should log fatal", function() {
|
|
this.logger.fatal(this.logArgs);
|
|
this.mockBunyanLogger.fatal.should.have.been.calledWith(this.logArgs);
|
|
});
|
|
|
|
it("should log info", function() {
|
|
this.logger.info(this.logArgs);
|
|
this.mockBunyanLogger.info.should.have.been.calledWith(this.logArgs);
|
|
});
|
|
|
|
it("should log warn", function() {
|
|
this.logger.warn(this.logArgs);
|
|
this.mockBunyanLogger.warn.should.have.been.calledWith(this.logArgs);
|
|
});
|
|
|
|
it("should log err", function() {
|
|
this.logger.err(this.logArgs);
|
|
this.mockBunyanLogger.error.should.have.been.calledWith(this.logArgs);
|
|
});
|
|
|
|
it("should log log", function() {
|
|
this.logger.log(this.logArgs);
|
|
this.mockBunyanLogger.info.should.have.been.calledWith(this.logArgs);
|
|
});
|
|
});
|
|
|
|
describe("logger.error", function() {
|
|
it("should report a single error to sentry", function() {
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.captureException.called.should.equal(true);
|
|
});
|
|
|
|
it("should report the same error to sentry only once", function() {
|
|
const error1 = new Error("this is the error");
|
|
this.logger.error({ foo: error1 }, "first message");
|
|
this.logger.error({ bar: error1 }, "second message");
|
|
this.captureException.callCount.should.equal(1);
|
|
});
|
|
|
|
it("should report two different errors to sentry individually", function() {
|
|
const error1 = new Error("this is the error");
|
|
const error2 = new Error("this is the error");
|
|
this.logger.error({ foo: error1 }, "first message");
|
|
this.logger.error({ bar: error2 }, "second message");
|
|
this.captureException.callCount.should.equal(2);
|
|
});
|
|
|
|
it("should remove the path from fs errors", function() {
|
|
const fsError = new Error(
|
|
"Error: ENOENT: no such file or directory, stat '/tmp/3279b8d0-da10-11e8-8255-efd98985942b'"
|
|
);
|
|
fsError.path = "/tmp/3279b8d0-da10-11e8-8255-efd98985942b";
|
|
this.logger.error({ err: fsError }, "message");
|
|
this.captureException
|
|
.calledWith(
|
|
sinon.match.has(
|
|
"message",
|
|
"Error: ENOENT: no such file or directory, stat"
|
|
)
|
|
)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("for multiple errors should only report a maximum of 5 errors to sentry", function() {
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.captureException.callCount.should.equal(5);
|
|
});
|
|
|
|
it("for multiple errors with a minute delay should report 10 errors to sentry", function() {
|
|
// the first five errors should be reported to sentry
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
// the following errors should not be reported
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
// allow a minute to pass
|
|
this.clock.tick(this.start + 61 * 1000);
|
|
// after a minute the next five errors should be reported to sentry
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
// the following errors should not be reported to sentry
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.logger.error({ foo: "bar" }, "message");
|
|
this.captureException.callCount.should.equal(10);
|
|
});
|
|
});
|
|
|
|
describe("checkLogLevel", function() {
|
|
it("should request log level override from google meta data service", function() {
|
|
this.logger.checkLogLevel();
|
|
const options = {
|
|
headers: {
|
|
"Metadata-Flavor": "Google"
|
|
},
|
|
uri: `http://metadata.google.internal/computeMetadata/v1/project/attributes/${
|
|
this.loggerName
|
|
}-setLogLevelEndTime`
|
|
};
|
|
this.Request.should.have.been.calledWithMatch(options);
|
|
});
|
|
|
|
describe("when request has error", function() {
|
|
beforeEach(function() {
|
|
this.Request.yields("error");
|
|
this.logger.checkLogLevel();
|
|
});
|
|
|
|
it("should only set default level", function() {
|
|
this.mockBunyanLogger.level.should.have.been.calledOnce.and.calledWith(
|
|
"debug"
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("when statusCode is not 200", function() {
|
|
beforeEach(function() {
|
|
this.Request.yields(null, { statusCode: 404 });
|
|
this.logger.checkLogLevel();
|
|
});
|
|
|
|
it("should only set default level", function() {
|
|
this.mockBunyanLogger.level.should.have.been.calledOnce.and.calledWith(
|
|
"debug"
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("when time value returned that is less than current time", function() {
|
|
beforeEach(function() {
|
|
this.Request.yields(null, { statusCode: 200 }, "1");
|
|
this.logger.checkLogLevel();
|
|
});
|
|
|
|
it("should only set default level", function() {
|
|
this.mockBunyanLogger.level.should.have.been.calledOnce.and.calledWith(
|
|
"debug"
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("when time value returned that is less than current time", function() {
|
|
describe("when level is already set", function() {
|
|
beforeEach(function() {
|
|
this.mockBunyanLogger.level.returns(10);
|
|
this.Request.yields(null, { statusCode: 200 }, this.start + 1000);
|
|
this.logger.checkLogLevel();
|
|
});
|
|
|
|
it("should set trace level", function() {
|
|
this.mockBunyanLogger.level.should.have.been.calledOnce.and.calledWith(
|
|
"trace"
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("when level is not already set", function() {
|
|
beforeEach(function() {
|
|
this.mockBunyanLogger.level.returns(20);
|
|
this.Request.yields(null, { statusCode: 200 }, this.start + 1000);
|
|
this.logger.checkLogLevel();
|
|
});
|
|
|
|
it("should set trace level", function() {
|
|
this.mockBunyanLogger.level.should.have.been.calledOnce.and.calledWith(
|
|
"trace"
|
|
);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("ringbuffer", function() {
|
|
beforeEach(function() {
|
|
this.logBufferMock = [
|
|
{
|
|
msg: "log 1"
|
|
},
|
|
{
|
|
msg: "log 2"
|
|
}
|
|
];
|
|
});
|
|
|
|
describe("in production", function() {
|
|
beforeEach(function() {
|
|
process.env["NODE_ENV"] = "production";
|
|
this.logger = this.LoggingManager.initialize(this.loggerName);
|
|
this.logger.ringBuffer.records = this.logBufferMock;
|
|
this.logger.error({}, "error");
|
|
});
|
|
|
|
afterEach(function() {
|
|
process.env["NODE_ENV"] = undefined;
|
|
});
|
|
|
|
it("should include buffered logs in error log", function() {
|
|
this.mockBunyanLogger.error.lastCall.args[0].logBuffer.should.equal(
|
|
this.logBufferMock
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("not in production", function() {
|
|
beforeEach(function() {
|
|
this.logger = this.LoggingManager.initialize(this.loggerName);
|
|
this.logger.ringBuffer.records = this.logBufferMock;
|
|
this.logger.error({}, "error");
|
|
});
|
|
|
|
it("should not include buffered logs in error log", function() {
|
|
chai.expect(this.mockBunyanLogger.error.lastCall.args[0].logBuffer).be
|
|
.undefined;
|
|
});
|
|
});
|
|
});
|
|
});
|