diagnostic-channel-publishers

  • Version 1.0.3
  • Published
  • 58.5 kB
  • No dependencies
  • MIT license

Install

npm i diagnostic-channel-publishers
yarn add diagnostic-channel-publishers
pnpm add diagnostic-channel-publishers

Overview

A collection of pre-built module patches that enable existing npm modules to publish diagnostic data

Index

Functions

function enable

enable: () => void;

    Interfaces

    interface IPostgresData

    interface IPostgresData {}

      property database

      database: {
      host: string;
      port: string;
      };

        property duration

        duration: number;

          property error

          error?: Error;

            property query

            query: {
            text?: string;
            plan?: string;
            preparable?: {
            text: string;
            args: any[];
            };
            };

              property result

              result?: IPostgresResult;

                property time

                time: Date;

                  interface IPostgresResult

                  interface IPostgresResult {}

                    property command

                    command: string;

                      property rowCount

                      rowCount: number;

                        Namespaces

                        namespace azuresdk

                        module 'dist/src/azure-coretracing.pub.d.ts' {}

                          variable azureCoreTracing

                          const azureCoreTracing: any;

                            variable AzureMonitorSymbol

                            const AzureMonitorSymbol: string;

                              function enable

                              enable: () => void;

                                namespace bunyan

                                module 'dist/src/bunyan.pub.d.ts' {}

                                  variable bunyan

                                  const bunyan: any;

                                    function enable

                                    enable: () => void;

                                      interface IBunyanData

                                      interface IBunyanData {}

                                        property level

                                        level: number;

                                          property result

                                          result: string;

                                            namespace console

                                            module 'dist/src/console.pub.d.ts' {}

                                              variable console

                                              const console: any;

                                                function enable

                                                enable: () => void;

                                                  interface IConsoleData

                                                  interface IConsoleData {}

                                                    property message

                                                    message: string;

                                                      property stderr

                                                      stderr?: boolean;

                                                        namespace mongodb

                                                        module 'dist/src/mongodb.pub.d.ts' {}

                                                          variable mongo2

                                                          const mongo2: any;

                                                            variable mongo3

                                                            const mongo3: any;

                                                              variable mongo330

                                                              const mongo330: any;

                                                                function enable

                                                                enable: () => void;

                                                                  interface IMongoData

                                                                  interface IMongoData {}

                                                                    property event

                                                                    event: {
                                                                    commandName?: string;
                                                                    duration?: number;
                                                                    failure?: string;
                                                                    reply?: any;
                                                                    };

                                                                      property startedData

                                                                      startedData: {
                                                                      databaseName?: string;
                                                                      command?: any;
                                                                      time: Date;
                                                                      };

                                                                        property succeeded

                                                                        succeeded: boolean;

                                                                          namespace mongodbCore

                                                                          module 'dist/src/mongodb-core.pub.d.ts' {}

                                                                            variable mongoCore

                                                                            const mongoCore: any;

                                                                              function enable

                                                                              enable: () => void;

                                                                                namespace mysql

                                                                                module 'dist/src/mysql.pub.d.ts' {}

                                                                                  variable mysql

                                                                                  const mysql: any;

                                                                                    function enable

                                                                                    enable: () => void;

                                                                                      interface IMysqlData

                                                                                      interface IMysqlData {}

                                                                                        property callbackArgs

                                                                                        callbackArgs: IArguments;

                                                                                          property duration

                                                                                          duration: number;

                                                                                            property err

                                                                                            err: Error;

                                                                                              property query

                                                                                              query: {
                                                                                              sql?: string;
                                                                                              _connection?: {
                                                                                              config?: {
                                                                                              socketPath?: string;
                                                                                              host?: string;
                                                                                              port?: number;
                                                                                              };
                                                                                              };
                                                                                              };

                                                                                                property time

                                                                                                time: Date;

                                                                                                  namespace pg

                                                                                                  module 'dist/src/pg.pub.d.ts' {}

                                                                                                    variable postgres6

                                                                                                    const postgres6: any;

                                                                                                      variable postgres7

                                                                                                      const postgres7: any;

                                                                                                        function enable

                                                                                                        enable: () => void;

                                                                                                          interface IPostgresData

                                                                                                          interface IPostgresData {}

                                                                                                            property database

                                                                                                            database: {
                                                                                                            host: string;
                                                                                                            port: string;
                                                                                                            };

                                                                                                              property duration

                                                                                                              duration: number;

                                                                                                                property error

                                                                                                                error?: Error;

                                                                                                                  property query

                                                                                                                  query: {
                                                                                                                  text?: string;
                                                                                                                  plan?: string;
                                                                                                                  preparable?: {
                                                                                                                  text: string;
                                                                                                                  args: any[];
                                                                                                                  };
                                                                                                                  };

                                                                                                                    property result

                                                                                                                    result?: IPostgresResult;

                                                                                                                      property time

                                                                                                                      time: Date;

                                                                                                                        interface IPostgresResult

                                                                                                                        interface IPostgresResult {}

                                                                                                                          property command

                                                                                                                          command: string;

                                                                                                                            property rowCount

                                                                                                                            rowCount: number;

                                                                                                                              namespace pgPool

                                                                                                                              module 'dist/src/pg-pool.pub.d.ts' {}

                                                                                                                                variable postgresPool1

                                                                                                                                const postgresPool1: any;

                                                                                                                                  function enable

                                                                                                                                  enable: () => void;

                                                                                                                                    namespace redis

                                                                                                                                    module 'dist/src/redis.pub.d.ts' {}

                                                                                                                                      variable redis

                                                                                                                                      const redis: any;

                                                                                                                                        function enable

                                                                                                                                        enable: () => void;

                                                                                                                                          interface IRedisData

                                                                                                                                          interface IRedisData {}

                                                                                                                                            property address

                                                                                                                                            address: string;

                                                                                                                                              property commandObj

                                                                                                                                              commandObj: any;

                                                                                                                                                property duration

                                                                                                                                                duration: number;

                                                                                                                                                  property err

                                                                                                                                                  err: Error;

                                                                                                                                                    property result

                                                                                                                                                    result: any;

                                                                                                                                                      property time

                                                                                                                                                      time: Date;

                                                                                                                                                        namespace tedious

                                                                                                                                                        module 'dist/src/tedious.pub.d.ts' {}

                                                                                                                                                          variable tedious

                                                                                                                                                          const tedious: any;

                                                                                                                                                            function enable

                                                                                                                                                            enable: () => void;

                                                                                                                                                              interface ITediousData

                                                                                                                                                              interface ITediousData {}

                                                                                                                                                                property database

                                                                                                                                                                database: {
                                                                                                                                                                host: string;
                                                                                                                                                                port: string;
                                                                                                                                                                };

                                                                                                                                                                  property duration

                                                                                                                                                                  duration: number;

                                                                                                                                                                    property error

                                                                                                                                                                    error?: Error;

                                                                                                                                                                      property query

                                                                                                                                                                      query: {
                                                                                                                                                                      text?: string;
                                                                                                                                                                      plan?: string;
                                                                                                                                                                      preparable?: {
                                                                                                                                                                      text: string;
                                                                                                                                                                      args: any[];
                                                                                                                                                                      };
                                                                                                                                                                      };

                                                                                                                                                                        property result

                                                                                                                                                                        result?: ITediousResult;

                                                                                                                                                                          interface ITediousResult

                                                                                                                                                                          interface ITediousResult {}

                                                                                                                                                                            property rowCount

                                                                                                                                                                            rowCount: number;

                                                                                                                                                                              property rows

                                                                                                                                                                              rows: any;

                                                                                                                                                                                namespace winston

                                                                                                                                                                                module 'dist/src/winston.pub.d.ts' {}

                                                                                                                                                                                  variable winston2

                                                                                                                                                                                  const winston2: any;

                                                                                                                                                                                    variable winston3

                                                                                                                                                                                    const winston3: any;

                                                                                                                                                                                      function enable

                                                                                                                                                                                      enable: () => void;

                                                                                                                                                                                        interface IWinstonData

                                                                                                                                                                                        interface IWinstonData {}

                                                                                                                                                                                          property level

                                                                                                                                                                                          level: string;

                                                                                                                                                                                            property levelKind

                                                                                                                                                                                            levelKind: string;

                                                                                                                                                                                              property message

                                                                                                                                                                                              message: string | Error;

                                                                                                                                                                                                property meta

                                                                                                                                                                                                meta: any;

                                                                                                                                                                                                  Package Files (12)

                                                                                                                                                                                                  Dependencies (0)

                                                                                                                                                                                                  No dependencies.

                                                                                                                                                                                                  Dev Dependencies (20)

                                                                                                                                                                                                  Peer Dependencies (1)

                                                                                                                                                                                                  Badge

                                                                                                                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/diagnostic-channel-publishers.

                                                                                                                                                                                                  • Markdown
                                                                                                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/diagnostic-channel-publishers)
                                                                                                                                                                                                  • HTML
                                                                                                                                                                                                    <a href="https://www.jsdocs.io/package/diagnostic-channel-publishers"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>