inversify-tracer

Tool that allows the developer to trace methods of objects created by InversifyJS.

Installation

You can get the latest release and the type definitions using npm:

$ npm install --save inversify-tracer

Example

import 'reflect-metadata';
import { decorate, injectable, Container } from 'inversify';
import { InversifyTracer, CallInfo, ReturnInfo } from './../src';

class Ninja  {

    public attack(force: number): number {
        return 32 * force;
    }

    public slowAttack(force: number, time: number): Promise<number> {

        return new Promise((resolve) => {

            setTimeout(() => {
                resolve(this.attack(force));
            }, time);
        });
    }
}

decorate(injectable(), Ninja);

const container = new Container();

container.bind<Ninja>('Ninja').to(Ninja);

const tracer = new InversifyTracer();

tracer.on('call', (callInfo: CallInfo) => {
    console.log(`${callInfo.className} ${callInfo.methodName} called with ${JSON.stringify(callInfo.parameters)}`);
});

tracer.on('return', (returnInfo: ReturnInfo) => {
    console.log(`${returnInfo.className} ${returnInfo.methodName} returned ${returnInfo.result} - ${returnInfo.executionTime}ms`);
});

tracer.apply(container);

const ninja = container.get<Ninja>('Ninja');

ninja.attack(2);
ninja.slowAttack(4, 1000);

Result:

Ninja attack called with [{"name":"force","value":2}]
Ninja attack returned 64 - 0ms
Ninja slowAttack called with [{"name":"force","value":4},{"name":"time","value":1000}]
Ninja attack called with [{"name":"force","value":4}]
Ninja attack returned 128 - 0ms
Ninja slowAttack returned 128 - 1004ms

Configuration

The configuration allows you to change the default behavior of the tracer. This configuration is passed through the InversifyTracer constructor. Example:

const tracer = new InversifyTracer({
    filters: ["*:*", "!Ninja:*"],
    inspectReturnedPromise: false
});

tracer.apply(container);

| Property | Type | Default | Description | |--- |--- |--- |--- | | filters | string[] | ['*:*'] | Filters that choose which classes and method will be traced | | inspectReturnedPromise| boolean | true | Inpect the value from the returned Promise object |

Filters

Filters allow you to specify the classes and/or functions you want to trace. By default, all classes and methods will be traced.

Filter examples:

['*:*', '!Ninja:*'] // trace every class, except Ninja
['Ninja:*', '!Ninja:hide'] // trace every method of the class Ninja, except the 'hide' method
['*:attack'] // trace attack method from every class
['Nin*:*'] // trace every method of the classes that start with 'Nin'

Events

Event: 'call'

• callInfo <CallInfo>

Emitted each time a class method is called.

CallInfo

| Property | Type | Description | |--- |--- |--- | | className | string | Name of the class | | methodName | string | Name of the method | | parameters | Parameter[] | Array with the name of the method's parameters and their value |

Event: 'return'

• returnInfo <ReturnInfo>

Emitted each time a class method ends.

ReturnInfo

| Property | Type | Description | |--- |--- |--- | | className | string | Name of the class | | methodName | string | Name of the method | | result | any | Returned value of the method | | executionTime | number | Method execution time in milliseconds |