caterpillar
Version:
Caterpillar is the ultimate logging system for Deno, Node.js, and Web Browsers. Log levels are implemented to the RFC standard. Log entries can be filtered and piped to various streams, including coloured output to the terminal, the browser's console, and
175 lines (174 loc) • 8.27 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Transform = void 0;
/**
* Caterpillar Transform Class.
* Provides the methods needed to provide a pipable Caterpillar Transform.
* Such that all you need to do is write your {@link Transform.format} method.
* It can pipe to anything that provides a {@link Pipeable.write} method.
* @example [Writing a Custom Transform](https://repl.it/@balupton/caterpillar-custom-transform)
*/
var Transform = /** @class */ (function () {
function Transform() {
/** Where is this Transform piping to? */
this.pipes = [];
/** Maintain a write queue such that multiple Deno writes do not stall */
this.writer = Promise.resolve();
}
/**
* Format the received log entry representation.
* Your transformer should extend this.
*/
Transform.prototype.format = function (message) {
return message;
};
/** Pipe future log entries into a caterpillar transform or a stream. */
Transform.prototype.pipe = function (to) {
this.pipes.push(to);
return to;
};
/** Write to the child pipes. */
Transform.prototype.write = function (chunk) {
var _this = this;
// format now, so that we have the correct stack
var data = this.format(chunk);
// exclude filtered entries
if (data == null)
return this.writer;
// now delegate back to the pipe
this.writer = this.writer.then(function () { return __awaiter(_this, void 0, void 0, function () {
var _a, _b, pipe, str, e_1_1;
var e_1, _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
_d.trys.push([0, 9, 10, 11]);
_a = __values(this.pipes), _b = _a.next();
_d.label = 1;
case 1:
if (!!_b.done) return [3 /*break*/, 8];
pipe = _b.value;
if (!(pipe instanceof Transform)) return [3 /*break*/, 3];
// compatibility with caterpillar transforms
return [4 /*yield*/, pipe.write(data)];
case 2:
// compatibility with caterpillar transforms
_d.sent();
return [3 /*break*/, 7];
case 3:
str = typeof data === 'string' ? data : JSON.stringify(data);
if (!(typeof TextEncoder !== 'undefined')) return [3 /*break*/, 5];
// compatibility with deno and later node streams
return [4 /*yield*/, pipe.write(new TextEncoder().encode(str))];
case 4:
// compatibility with deno and later node streams
_d.sent();
return [3 /*break*/, 7];
case 5:
// compatibility with earlier node streams
return [4 /*yield*/, pipe.write(str)];
case 6:
// compatibility with earlier node streams
_d.sent();
_d.label = 7;
case 7:
_b = _a.next();
return [3 /*break*/, 1];
case 8: return [3 /*break*/, 11];
case 9:
e_1_1 = _d.sent();
e_1 = { error: e_1_1 };
return [3 /*break*/, 11];
case 10:
try {
if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
}
finally { if (e_1) throw e_1.error; }
return [7 /*endfinally*/];
case 11: return [2 /*return*/];
}
});
}); });
return this.writer;
};
/** Close the child pipes. */
Transform.prototype.close = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, Promise.all(this.pipes.map(function (pipe) {
if (pipe.close) {
return pipe.close();
}
else if (pipe.end) {
return new Promise(function (resolve) {
pipe.end(resolve);
});
}
else {
return Promise.resolve();
}
}))];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
/* Callback alias for close */
Transform.prototype.end = function (cb) {
var p = this.close();
if (cb)
p.finally(cb);
};
return Transform;
}());
exports.Transform = Transform;