Talend-log - error logging library

A small library that provides redux-logger middleware for error logging to be applied as errorTransformer.

Exports redux-logger compatible error logging middleware.

#### Minimum-config usage:

your configStore.js file:

import { createStore, applyMiddleware } from 'redux';
import thunkMiddleware from 'redux-thunk';
import promise from 'redux-promise-middleware';
import createLogger from 'redux-logger';
import LOGGING_SERVER_URL from 'somewhere';
import initErrorTransformer, { TraceKit } from 'talend-log';

// important part:
const logger = createLogger({ errorTransformer: initErrorTransformer(LOGGING_SERVER_URL) });
// :end of important part

const createStoreWithMiddleware = applyMiddleware(thunkMiddleware, promise(), logger)(createStore);
export default function configureStore(reducer, initialState) {
const store = createStoreWithMiddleware(reducer, initialState);
// drop a reference to store instance for later use in errorLogging reportMiddleware
TraceKit.store = store;
return store;
}

#### Advanced config
Look in ./src/errorTransformer.js for jsDoc on each parameter

import LOGGING_SERVER_URL from 'somewhere';
import initErrorTransformer from 'talend-log';

const logger = createLogger({
errorTransformer: initErrorTransformer(
LOGGING_SERVER_URL, {
send: (payload, fetchOptions) => fetch(LOGGING_SERVER_URL, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
'@message': payload
}),
...fetchOptions,
}),
payloadMiddleware: payload => Object.assign({
state: TraceKit.store.getState()
}, payload),
fetchOptions: {
headers: {
'Content-Type': 'application/json',
custom: 'customData'
}
},
successHandler: (responseText) => {
alert('yay! ' + responseText)
},
retryCount: 5,
retryTimeout: 3000,
failedTryHandler: function failedTry(error, payload, transportOpts, attempt) {
alert('Oh no! ' + error);
transportOpts.send(transportOpts.payloadMiddleware(payload), transportOpts.fetchOptions, attempt + 1);
},
failedReportHandler: (errorResponse) => {
alert('oh no! ' + errorResponse)
},
}, {
stackTraceLimit: 100,
linesOfContext: 13,
rethrowErrorHandler: () => {},
remoteFetching: true,
collectWindowErrors: true,
}
)
});

Notable details:
- Once initErrorTransformer is called, listener function is created and registered in TraceKit, then returned.
- Depending on the parameters you provide, TraceKit.report function may be patched to rethrow no error.
- transport.send is called with fetchOptions defined on transport.fetchOptions
- TraceKit.store should be defined in your configStore.js file if you want to attach state to report
- fetchOptions are merged with Object.assign to default options, so don't expect deepMerge
- that is also true for default transport and default options objects

#### Log warnings

If you have some non-critical exceptions that should be reported, but should not break application, then use a possibility to provide handler for better microcontrol:

in your config file:

import LOGGING_SERVER_URL from 'somewhere';
import initErrorTransformer from 'talend-log';
import transportConfig from 'somewhere';

// this:
initErrorTransformer(LOGGING_SERVER_URL, transportConfig, {
rethrowErrorHandler: (e) => { if (e.type === 'critical') { throw e; } else { console.error(e); } },
})

somewhere in your application:

import { TraceKit } from 'talend-log';

fetch('google.com').catch(errorResponse => TraceKit.report(new Error(errorResponse)));

$3

TraceKit - Cross browser stack traces. https://github.com/csnover/TraceKit