1 | "use strict";
|
2 | Object.defineProperty(exports, "__esModule", { value: true });
|
3 | exports.enable = exports.postgres7 = exports.postgres6 = void 0;
|
4 |
|
5 |
|
6 | var diagnostic_channel_1 = require("diagnostic-channel");
|
7 | var events_1 = require("events");
|
8 | var publisherName = "postgres";
|
9 | function postgres6PatchFunction(originalPg, originalPgPath) {
|
10 | var originalClientQuery = originalPg.Client.prototype.query;
|
11 | var diagnosticOriginalFunc = "__diagnosticOriginalFunc";
|
12 |
|
13 |
|
14 | originalPg.Client.prototype.query = function query(config, values, callback) {
|
15 | var data = {
|
16 | query: {},
|
17 | database: {
|
18 | host: this.connectionParameters.host,
|
19 | port: this.connectionParameters.port
|
20 | },
|
21 | result: null,
|
22 | error: null,
|
23 | duration: 0,
|
24 | time: new Date()
|
25 | };
|
26 | var start = process.hrtime();
|
27 | var queryResult;
|
28 | function patchCallback(cb) {
|
29 | if (cb && cb[diagnosticOriginalFunc]) {
|
30 | cb = cb[diagnosticOriginalFunc];
|
31 | }
|
32 | var trackingCallback = diagnostic_channel_1.channel.bindToContext(function (err, res) {
|
33 | var end = process.hrtime(start);
|
34 | data.result = res && { rowCount: res.rowCount, command: res.command };
|
35 | data.error = err;
|
36 | data.duration = Math.ceil((end[0] * 1e3) + (end[1] / 1e6));
|
37 | diagnostic_channel_1.channel.publish(publisherName, data);
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 | if (err) {
|
45 | if (cb) {
|
46 | return cb.apply(this, arguments);
|
47 | }
|
48 | else if (queryResult && queryResult instanceof events_1.EventEmitter) {
|
49 | queryResult.emit("error", err);
|
50 | }
|
51 | }
|
52 | else if (cb) {
|
53 | cb.apply(this, arguments);
|
54 | }
|
55 | });
|
56 | try {
|
57 | Object.defineProperty(trackingCallback, diagnosticOriginalFunc, { value: cb });
|
58 | return trackingCallback;
|
59 | }
|
60 | catch (e) {
|
61 |
|
62 | return cb;
|
63 | }
|
64 | }
|
65 |
|
66 |
|
67 |
|
68 |
|
69 | try {
|
70 | if (typeof config === "string") {
|
71 | if (values instanceof Array) {
|
72 | data.query.preparable = {
|
73 | text: config,
|
74 | args: values
|
75 | };
|
76 | callback = patchCallback(callback);
|
77 | }
|
78 | else {
|
79 | data.query.text = config;
|
80 |
|
81 |
|
82 |
|
83 |
|
84 |
|
85 | if (callback) {
|
86 | callback = patchCallback(callback);
|
87 | }
|
88 | else {
|
89 | values = patchCallback(values);
|
90 | }
|
91 | }
|
92 | }
|
93 | else {
|
94 | if (typeof config.name === "string") {
|
95 | data.query.plan = config.name;
|
96 | }
|
97 | else if (config.values instanceof Array) {
|
98 | data.query.preparable = {
|
99 | text: config.text,
|
100 | args: config.values
|
101 | };
|
102 | }
|
103 | else {
|
104 | data.query.text = config.text;
|
105 | }
|
106 | if (callback) {
|
107 | callback = patchCallback(callback);
|
108 | }
|
109 | else if (values) {
|
110 | values = patchCallback(values);
|
111 | }
|
112 | else {
|
113 | config.callback = patchCallback(config.callback);
|
114 | }
|
115 | }
|
116 | }
|
117 | catch (e) {
|
118 |
|
119 | return originalClientQuery.apply(this, arguments);
|
120 | }
|
121 | arguments[0] = config;
|
122 | arguments[1] = values;
|
123 | arguments[2] = callback;
|
124 | arguments.length = (arguments.length > 3) ? arguments.length : 3;
|
125 | queryResult = originalClientQuery.apply(this, arguments);
|
126 | return queryResult;
|
127 | };
|
128 | return originalPg;
|
129 | }
|
130 | function postgres7PatchFunction(originalPg, originalPgPath) {
|
131 | var originalClientQuery = originalPg.Client.prototype.query;
|
132 | var diagnosticOriginalFunc = "__diagnosticOriginalFunc";
|
133 |
|
134 |
|
135 | originalPg.Client.prototype.query = function query(config, values, callback) {
|
136 | var _this = this;
|
137 | var callbackProvided = !!callback;
|
138 | var data = {
|
139 | query: {},
|
140 | database: {
|
141 | host: this.connectionParameters.host,
|
142 | port: this.connectionParameters.port
|
143 | },
|
144 | result: null,
|
145 | error: null,
|
146 | duration: 0,
|
147 | time: new Date()
|
148 | };
|
149 | var start = process.hrtime();
|
150 | var queryResult;
|
151 | function patchCallback(cb) {
|
152 | if (cb && cb[diagnosticOriginalFunc]) {
|
153 | cb = cb[diagnosticOriginalFunc];
|
154 | }
|
155 | var trackingCallback = diagnostic_channel_1.channel.bindToContext(function (err, res) {
|
156 | var end = process.hrtime(start);
|
157 | data.result = res && { rowCount: res.rowCount, command: res.command };
|
158 | data.error = err;
|
159 | data.duration = Math.ceil((end[0] * 1e3) + (end[1] / 1e6));
|
160 | diagnostic_channel_1.channel.publish(publisherName, data);
|
161 | if (err) {
|
162 | if (cb) {
|
163 | return cb.apply(this, arguments);
|
164 | }
|
165 | else if (queryResult && queryResult instanceof events_1.EventEmitter) {
|
166 | queryResult.emit("error", err);
|
167 | }
|
168 | }
|
169 | else if (cb) {
|
170 | cb.apply(this, arguments);
|
171 | }
|
172 | });
|
173 | try {
|
174 | Object.defineProperty(trackingCallback, diagnosticOriginalFunc, { value: cb });
|
175 | return trackingCallback;
|
176 | }
|
177 | catch (e) {
|
178 |
|
179 | return cb;
|
180 | }
|
181 | }
|
182 |
|
183 |
|
184 |
|
185 | try {
|
186 | if (typeof config === "string") {
|
187 | if (values instanceof Array) {
|
188 | data.query.preparable = {
|
189 | text: config,
|
190 | args: values
|
191 | };
|
192 | callbackProvided = typeof callback === "function";
|
193 | callback = callbackProvided ? patchCallback(callback) : callback;
|
194 | }
|
195 | else {
|
196 | data.query.text = config;
|
197 | if (callback) {
|
198 | callbackProvided = typeof callback === "function";
|
199 | callback = callbackProvided ? patchCallback(callback) : callback;
|
200 | }
|
201 | else {
|
202 | callbackProvided = typeof values === "function";
|
203 | values = callbackProvided ? patchCallback(values) : values;
|
204 | }
|
205 | }
|
206 | }
|
207 | else {
|
208 | if (typeof config.name === "string") {
|
209 | data.query.plan = config.name;
|
210 | }
|
211 | else if (config.values instanceof Array) {
|
212 | data.query.preparable = {
|
213 | text: config.text,
|
214 | args: config.values
|
215 | };
|
216 | }
|
217 | else {
|
218 | data.query.text = config.text;
|
219 | }
|
220 | if (callback) {
|
221 | callbackProvided = typeof callback === "function";
|
222 | callback = patchCallback(callback);
|
223 | }
|
224 | else if (values) {
|
225 | callbackProvided = typeof values === "function";
|
226 | values = callbackProvided ? patchCallback(values) : values;
|
227 | }
|
228 | else {
|
229 | callbackProvided = typeof config.callback === "function";
|
230 | config.callback = callbackProvided ? patchCallback(config.callback) : config.callback;
|
231 | }
|
232 | }
|
233 | }
|
234 | catch (e) {
|
235 |
|
236 | return originalClientQuery.apply(this, arguments);
|
237 | }
|
238 | arguments[0] = config;
|
239 | arguments[1] = values;
|
240 | arguments[2] = callback;
|
241 | arguments.length = (arguments.length > 3) ? arguments.length : 3;
|
242 | queryResult = originalClientQuery.apply(this, arguments);
|
243 | if (!callbackProvided) {
|
244 |
|
245 | return queryResult
|
246 |
|
247 | .then(function (result) {
|
248 | patchCallback()(undefined, result);
|
249 | return new _this._Promise(function (resolve, reject) {
|
250 | resolve(result);
|
251 | });
|
252 | })
|
253 |
|
254 | .catch(function (error) {
|
255 | patchCallback()(error, undefined);
|
256 | return new _this._Promise(function (resolve, reject) {
|
257 | reject(error);
|
258 | });
|
259 | });
|
260 | }
|
261 | return queryResult;
|
262 | };
|
263 | return originalPg;
|
264 | }
|
265 | exports.postgres6 = {
|
266 | versionSpecifier: "6.*",
|
267 | patch: postgres6PatchFunction
|
268 | };
|
269 | exports.postgres7 = {
|
270 | versionSpecifier: ">=7.* <=8.*",
|
271 | patch: postgres7PatchFunction,
|
272 | publisherName: publisherName
|
273 | };
|
274 | function enable() {
|
275 | diagnostic_channel_1.channel.registerMonkeyPatch("pg", exports.postgres6);
|
276 | diagnostic_channel_1.channel.registerMonkeyPatch("pg", exports.postgres7);
|
277 | }
|
278 | exports.enable = enable;
|
279 |
|
\ | No newline at end of file |