fix: resolve logger as log from container

Brian Faust · Brian Faust · commit daf1d922a907 · 2019-08-22T09:21:08.000+03:00
diff --git a/packages/core-api/src/server.ts b/packages/core-api/src/server.ts
@@ -3,7 +3,7 @@ import { app, Contracts } from "@arkecosystem/core-kernel";
 import Hapi from "@hapi/hapi";
 
 export class Server {
-    private logger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private logger = app.resolve<Contracts.Kernel.ILogger>("log");
 
     private http: any;
     private https: any;
diff --git a/packages/core-api/src/service-provider.ts b/packages/core-api/src/service-provider.ts
@@ -5,7 +5,7 @@ import { Server } from "./server";
 export class ServiceProvider extends Support.AbstractServiceProvider {
     public async register(): Promise<void> {
         if (!this.opts.enabled) {
-            this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Public API is disabled");
+            this.app.resolve<Contracts.Kernel.ILogger>("log").info("Public API is disabled");
             return;
         }
 
@@ -18,7 +18,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
 
     public async dispose(): Promise<void> {
         if (this.opts.enabled) {
-            this.app.resolve<Contracts.Kernel.ILogger>("logger").info(`Stopping Public API`);
+            this.app.resolve<Contracts.Kernel.ILogger>("log").info(`Stopping Public API`);
 
             await this.app.resolve<Server>("api").stop();
         }
diff --git a/packages/core-blockchain/src/processor/block-processor.ts b/packages/core-blockchain/src/processor/block-processor.ts
@@ -23,7 +23,7 @@ export enum BlockProcessorResult {
 }
 
 export class BlockProcessor {
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
 
     public constructor(private readonly blockchain: Blockchain) {}
 
diff --git a/packages/core-blockchain/src/processor/handlers/block-handler.ts b/packages/core-blockchain/src/processor/handlers/block-handler.ts
@@ -4,7 +4,7 @@ import { Blockchain } from "../../blockchain";
 import { BlockProcessorResult } from "../block-processor";
 
 export abstract class BlockHandler {
-    protected readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    protected readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
 
     public constructor(protected readonly blockchain: Blockchain, protected readonly block: Interfaces.IBlock) {}
 
diff --git a/packages/core-blockchain/src/replay/replay-blockchain.ts b/packages/core-blockchain/src/replay/replay-blockchain.ts
@@ -25,7 +25,7 @@ export class ReplayBlockchain extends Blockchain {
         this.walletManager = new Wallets.WalletManager();
         this.memoryDatabase = new MemoryDatabaseService(this.walletManager);
 
-        this.logger = app.resolve<Contracts.Kernel.ILogger>("logger");
+        this.logger = app.resolve<Contracts.Kernel.ILogger>("log");
         this.localDatabase = app.resolve<Contracts.Database.IDatabaseService>("database");
         this.localDatabase.walletManager = this.walletManager;
 
diff --git a/packages/core-blockchain/src/state-machine.ts b/packages/core-blockchain/src/state-machine.ts
@@ -117,7 +117,7 @@ blockchainMachine.actionMap = (blockchain: Blockchain) => ({
     },
 
     async init() {
-        logger = app.resolve<Contracts.Kernel.ILogger>("logger");
+        logger = app.resolve<Contracts.Kernel.ILogger>("log");
         stateStorage = app.resolve<Contracts.State.IStateService>("state").getStore();
         blockchainMachine.state = stateStorage;
 
diff --git a/packages/core-blockchain/src/utils/tick-sync-tracker.ts b/packages/core-blockchain/src/utils/tick-sync-tracker.ts
@@ -44,7 +44,7 @@ export const tickSyncTracker = (blockCount, count): void => {
             secondsDecimalDigits: 0,
         });
 
-        app.resolve<Contracts.Kernel.ILogger>("logger").info(
+        app.resolve<Contracts.Kernel.ILogger>("log").info(
             `Synchronising In Progress (${blocksDownloaded} of ${networkHeight} blocks - Est. ${timeLeft})`,
         );
     }
diff --git a/packages/core-blockchain/src/utils/validate-generator.ts b/packages/core-blockchain/src/utils/validate-generator.ts
@@ -4,7 +4,7 @@ import { Crypto, Interfaces } from "@arkecosystem/crypto";
 
 export const validateGenerator = async (block: Interfaces.IBlock): Promise<boolean> => {
     const database: Contracts.Database.IDatabaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
-    const logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    const logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
 
     const roundInfo: Contracts.Shared.IRoundInfo = roundCalculator.calculateRound(block.data.height);
     const delegates: Contracts.State.IWallet[] = await database.getActiveDelegates(roundInfo);
diff --git a/packages/core-database-postgres/src/postgres-connection.ts b/packages/core-database-postgres/src/postgres-connection.ts
@@ -31,7 +31,7 @@ export class PostgresConnection implements Contracts.Database.IConnection {
     public walletsRepository: Contracts.Database.IWalletsRepository;
     // @TODO: make this private
     public pgp: IMain;
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     private readonly emitter: Contracts.Kernel.IEventDispatcher = app.resolve<Contracts.Kernel.IEventDispatcher>(
         "events",
     );
diff --git a/packages/core-database-postgres/src/service-provider.ts b/packages/core-database-postgres/src/service-provider.ts
@@ -6,7 +6,7 @@ import { PostgresConnection } from "./postgres-connection";
 
 export class ServiceProvider extends Support.AbstractServiceProvider {
     public async register(): Promise<void> {
-        this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Establishing Database Connection");
+        this.app.resolve<Contracts.Kernel.ILogger>("log").info("Establishing Database Connection");
 
         const walletManager = new Wallets.WalletManager();
 
@@ -17,7 +17,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
     }
 
     public async dispose(): Promise<void> {
-        this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Closing Database Connection");
+        this.app.resolve<Contracts.Kernel.ILogger>("log").info("Closing Database Connection");
 
         await this.app.resolve<Contracts.Database.IDatabaseService>("database").connection.disconnect();
     }
diff --git a/packages/core-database-postgres/src/state-builder.ts b/packages/core-database-postgres/src/state-builder.ts
@@ -3,7 +3,7 @@ import { Handlers } from "@arkecosystem/core-transactions";
 import { Interfaces, Managers, Utils } from "@arkecosystem/crypto";
 
 export class StateBuilder {
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     private readonly emitter: Contracts.Kernel.IEventDispatcher = app.resolve<Contracts.Kernel.IEventDispatcher>(
         "events",
     );
diff --git a/packages/core-database-postgres/src/utils.ts b/packages/core-database-postgres/src/utils.ts
@@ -29,7 +29,7 @@ export const loadQueryFile = (directory, file): QueryFile => {
     });
 
     if (query.error) {
-        app.resolve<Contracts.Kernel.ILogger>("logger").error(query.error.toString());
+        app.resolve<Contracts.Kernel.ILogger>("log").error(query.error.toString());
     }
 
     return query;
diff --git a/packages/core-database/src/database-service.ts b/packages/core-database/src/database-service.ts
@@ -9,7 +9,7 @@ import cloneDeep from "lodash.clonedeep";
 export class DatabaseService implements Contracts.Database.IDatabaseService {
     public connection: Contracts.Database.IConnection;
     public walletManager: Contracts.State.IWalletManager;
-    public logger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    public logger = app.resolve<Contracts.Kernel.ILogger>("log");
     public emitter = app.resolve<Contracts.Kernel.IEventDispatcher>("events");
     public options: any;
     public wallets: Contracts.Database.IWalletsBusinessRepository;
diff --git a/packages/core-database/src/service-provider.ts b/packages/core-database/src/service-provider.ts
@@ -3,7 +3,7 @@ import { ConnectionManager } from "./manager";
 
 export class ServiceProvider extends Support.AbstractServiceProvider {
     public async register(): Promise<void> {
-        this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Starting Database Manager");
+        this.app.resolve<Contracts.Kernel.ILogger>("log").info("Starting Database Manager");
 
         this.app.singleton("database-manager", ConnectionManager);
     }
diff --git a/packages/core-elasticsearch/src/indices/base.ts b/packages/core-elasticsearch/src/indices/base.ts
@@ -7,7 +7,7 @@ export abstract class Index {
     protected readonly emitter: Contracts.Kernel.IEventDispatcher = app.resolve<Contracts.Kernel.IEventDispatcher>(
         "events",
     );
-    protected readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    protected readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     protected readonly database: Contracts.Database.IDatabaseService = app.resolve<Contracts.Database.IDatabaseService>(
         "database",
     );
diff --git a/packages/core-elasticsearch/src/indices/index.ts b/packages/core-elasticsearch/src/indices/index.ts
@@ -10,7 +10,7 @@ export const watchIndices = async (chunkSize: number): Promise<void> => {
     for (const Indicer of indicers) {
         const instance = new Indicer(chunkSize);
 
-        app.resolve<Contracts.Kernel.ILogger>("logger").info(`[ES] Initialising ${instance.constructor.name}`);
+        app.resolve<Contracts.Kernel.ILogger>("log").info(`[ES] Initialising ${instance.constructor.name}`);
 
         await instance.index();
 
diff --git a/packages/core-exchange-json-rpc/src/index.ts b/packages/core-exchange-json-rpc/src/index.ts
@@ -6,7 +6,7 @@ import { defaults } from "./defaults";
 export class ServiceProvider extends Support.AbstractServiceProvider {
     public async register(): Promise<void> {
         if (!this.opts.enabled) {
-            this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Exchange JSON-RPC Server is disabled");
+            this.app.resolve<Contracts.Kernel.ILogger>("log").info("Exchange JSON-RPC Server is disabled");
             return;
         }
 
@@ -17,14 +17,14 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
             await start({
                 database: this.opts.database as string,
                 server: this.opts,
-                logger: this.app.resolve<Contracts.Kernel.ILogger>("logger"),
+                logger: this.app.resolve<Contracts.Kernel.ILogger>("log"),
             }),
         );
     }
 
     public async dispose(): Promise<void> {
         if (this.opts.enabled) {
-            this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Stopping Exchange JSON-RPC Server");
+            this.app.resolve<Contracts.Kernel.ILogger>("log").info("Stopping Exchange JSON-RPC Server");
 
             await this.app.resolve("exchange-json-rpc").stop();
         }
diff --git a/packages/core-explorer/src/index.ts b/packages/core-explorer/src/index.ts
@@ -10,7 +10,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
 
         if (!existsSync(distPath)) {
             this.app
-                .resolve<Contracts.Kernel.ILogger>("logger")
+                .resolve<Contracts.Kernel.ILogger>("log")
                 .error(`The ${distPath} directory does not exist. Please build the explorer before using this plugin.`);
             return;
         }
@@ -26,7 +26,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
         // @ts-ignore
         const server = app.listen(this.opts.server.port, this.opts.server.host, () => {
             this.app
-                .resolve<Contracts.Kernel.ILogger>("logger")
+                .resolve<Contracts.Kernel.ILogger>("log")
                 // @ts-ignore
                 .info(`Explorer is listening on http://${server.address().address}:${server.address().port}.`);
         });
@@ -36,7 +36,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
 
     public async dispose(): Promise<void> {
         try {
-            this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Stopping Explorer");
+            this.app.resolve<Contracts.Kernel.ILogger>("log").info("Stopping Explorer");
 
             await this.app.resolve("explorer").close();
         } catch (error) {
diff --git a/packages/core-forger/src/client.ts b/packages/core-forger/src/client.ts
@@ -8,7 +8,7 @@ import { IRelayHost } from "./interfaces";
 
 export class Client {
     public hosts: IRelayHost[];
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     private host: IRelayHost;
 
     constructor(hosts: IRelayHost[]) {
diff --git a/packages/core-forger/src/manager.ts b/packages/core-forger/src/manager.ts
@@ -10,7 +10,7 @@ import { Delegate } from "./delegate";
 import { HostNoResponseError, RelayCommunicationError } from "./errors";
 
 export class ForgerManager {
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
 
     private secrets: string[];
     private network: Types.NetworkType;
diff --git a/packages/core-forger/src/service-provider.ts b/packages/core-forger/src/service-provider.ts
@@ -19,7 +19,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
         const forger = this.app.resolve("forger");
 
         if (forger) {
-            this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Stopping Forger Manager");
+            this.app.resolve<Contracts.Kernel.ILogger>("log").info("Stopping Forger Manager");
 
             return forger.stopForging();
         }
diff --git a/packages/core-http-utils/src/server/mount.ts b/packages/core-http-utils/src/server/mount.ts
@@ -4,7 +4,7 @@ export const mountServer = async (name, server) => {
     try {
         await server.start();
 
-        app.resolve("logger").info(`${name} Server running at: ${server.info.uri}`);
+        app.resolve("log").info(`${name} Server running at: ${server.info.uri}`);
 
         return server;
     } catch (error) {
diff --git a/packages/core-kernel/src/application.ts b/packages/core-kernel/src/application.ts
@@ -190,7 +190,7 @@ export class Application extends Container implements Kernel.IApplication {
      * @memberof Application
      */
     public logPath(path: string = ""): string {
-        return join(this.getPath("logger"), path);
+        return join(this.getPath("log"), path);
     }
 
     /**
@@ -330,7 +330,7 @@ export class Application extends Container implements Kernel.IApplication {
      * @memberof Application
      */
     public get log(): Contracts.Kernel.ILogger {
-        return this.resolve<Contracts.Kernel.ILogger>("logger");
+        return this.resolve<Contracts.Kernel.ILogger>("log");
     }
 
     /**
diff --git a/packages/core-p2p/src/network-monitor.ts b/packages/core-p2p/src/network-monitor.ts
@@ -20,7 +20,7 @@ export class NetworkMonitor implements Contracts.P2P.INetworkMonitor {
     public nextUpdateNetworkStatusScheduled: boolean;
     private initializing: boolean = true;
 
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     private readonly emitter: Contracts.Kernel.IEventDispatcher = app.resolve<Contracts.Kernel.IEventDispatcher>(
         "events",
     );
diff --git a/packages/core-p2p/src/peer-communicator.ts b/packages/core-p2p/src/peer-communicator.ts
@@ -11,7 +11,7 @@ import { replySchemas } from "./schemas";
 import { isValidVersion, socketEmit } from "./utils";
 
 export class PeerCommunicator implements Contracts.P2P.IPeerCommunicator {
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     private readonly emitter: Contracts.Kernel.IEventDispatcher = app.resolve<Contracts.Kernel.IEventDispatcher>(
         "events",
     );
diff --git a/packages/core-p2p/src/peer-processor.ts b/packages/core-p2p/src/peer-processor.ts
@@ -8,7 +8,7 @@ export class PeerProcessor implements Contracts.P2P.IPeerProcessor {
     public server: any;
     public nextUpdateNetworkStatusScheduled: boolean;
 
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     private readonly emitter: Contracts.Kernel.IEventDispatcher = app.resolve<Contracts.Kernel.IEventDispatcher>(
         "events",
     );
diff --git a/packages/core-p2p/src/peer-verifier.ts b/packages/core-p2p/src/peer-verifier.ts
@@ -23,7 +23,7 @@ export class PeerVerifier {
     private readonly database: Contracts.Database.IDatabaseService = app.resolve<Contracts.Database.IDatabaseService>(
         "database",
     );
-    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");
+    private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");
     private logPrefix: string;
 
     public constructor(
diff --git a/packages/core-p2p/src/service-provider.ts b/packages/core-p2p/src/service-provider.ts
@@ -13,7 +13,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
     public async register(): Promise<void> {
         this.app.bind("p2p.options", this.opts);
 
-        this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Starting P2P Interface");
+        this.app.resolve<Contracts.Kernel.ILogger>("log").info("Starting P2P Interface");
 
         const service: Contracts.P2P.IPeerService = this.makePeerService(this.opts);
 
@@ -28,7 +28,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {
     }
 
     public async dispose(): Promise<void> {
-        this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Stopping P2P Interface");
+        this.app.resolve<Contracts.Kernel.ILogger>("log").info("Stopping P2P Interface");
 
         this.app
             .resolve<Contracts.P2P.IPeerService>("p2p")
diff --git a/packages/core-p2p/src/socket-server/index.ts b/packages/core-p2p/src/socket-server/index.ts
@@ -35,7 +35,7 @@ export const startSocketServer = async (
         ...config.server,
     });
 
-    server.on("fail", data => app.resolve<Contracts.Kernel.ILogger>("logger").error(data.message));
+    server.on("fail", data => app.resolve<Contracts.Kernel.ILogger>("log").error(data.message));
 
     // socketcluster types do not allow on("workerMessage") so casting as any
     (server as any).on("workerMessage", async (workerId, req, res) => {
@@ -67,7 +67,7 @@ export const startSocketServer = async (
                 return res(error);
             }
 
-            app.resolve<Contracts.Kernel.ILogger>("logger").error(error.message);
+            app.resolve<Contracts.Kernel.ILogger>("log").error(error.message);
             return res(new Error(`${req.endpoint} responded with ${error.message}`));
         }
     });
diff --git a/packages/core-p2p/src/socket-server/payload-processor.ts b/packages/core-p2p/src/socket-server/payload-processor.ts
@@ -68,7 +68,7 @@ class PayloadProcessor {
                     });
                     saveToDB(this.payloadOverflowQueue);
                 } catch (error) {
-                    app.resolve<Contracts.Kernel.ILogger>("logger").warning(
+                    app.resolve<Contracts.Kernel.ILogger>("log").warning(
                         `Discarding ${pluralize(
                             "transaction payload",
                             overflowQueueSize,
diff --git a/packages/core-p2p/src/socket-server/versions/internal.ts b/packages/core-p2p/src/socket-server/versions/internal.ts
@@ -63,7 +63,7 @@ export const getNetworkState = async ({
 };
 
 export const syncBlockchain = (): void => {
-    app.resolve<Contracts.Kernel.ILogger>("logger").debug("Blockchain sync check WAKEUP requested by forger");
+    app.resolve<Contracts.Kernel.ILogger>("log").debug("Blockchain sync check WAKEUP requested by forger");
 
     app.resolve<Contracts.Blockchain.IBlockchain>("blockchain").forceWakeup();
 };
diff --git a/packages/core-p2p/src/socket-server/versions/peer.ts b/packages/core-p2p/src/socket-server/versions/peer.ts
@@ -68,7 +68,7 @@ export const postBlock = async ({ req }): Promise<void> => {
         }
     }
 
-    app.resolve<Contracts.Kernel.ILogger>("logger").info(
+    app.resolve<Contracts.Kernel.ILogger>("log").info(
         `Received new block at height ${block.height.toLocaleString()} with ${pluralize(
             "transaction",
             block.numberOfTransactions,
@@ -118,7 +118,7 @@ export const getBlocks = async ({ req }): Promise<Interfaces.IBlockData[] | Cont
         blocks = await database.getBlocks(reqBlockHeight, reqBlockLimit, reqHeadersOnly);
     }
 
-    app.resolve<Contracts.Kernel.ILogger>("logger").info(
+    app.resolve<Contracts.Kernel.ILogger>("log").info(
         `${mapAddr(req.headers.remoteAddress)} has downloaded ${pluralize(
             "block",
             blocks.length,
diff --git a/packages/core-p2p/src/socket-server/versions/utils.ts b/packages/core-p2p/src/socket-server/versions/utils.ts
@@ -23,7 +23,7 @@ export const getHandlers = (): { [key: string]: string[] } => {
 };
 
 export const log = ({ req }): void => {
-    app.resolve("logger")[req.data.level](req.data.message);
+    app.resolve("log")[req.data.level](req.data.message);
 };
 
 export const isForgerAuthorized = ({ req }): { authorized: boolean } => {
diff --git a/packages/core-p2p/src/utils/check-dns.ts b/packages/core-p2p/src/utils/check-dns.ts
@@ -14,7 +14,7 @@ export const checkDNS = async hosts => {
 
             return Promise.resolve(hosts[i]);
         } catch (err) {
-            app.resolve<Contracts.Kernel.ILogger>("logger").error(err.message);
+            app.resolve<Contracts.Kernel.ILogger>("log").error(err.message);
         }
     }
 
diff --git a/packages/core-p2p/src/utils/check-ntp.ts b/packages/core-p2p/src/utils/check-ntp.ts
diff --git a/packages/core-snapshots/src/db/index.ts b/packages/core-snapshots/src/db/index.ts
diff --git a/packages/core-snapshots/src/db/utils/index.ts b/packages/core-snapshots/src/db/utils/index.ts
diff --git a/packages/core-snapshots/src/manager.ts b/packages/core-snapshots/src/manager.ts
diff --git a/packages/core-snapshots/src/transport/index.ts b/packages/core-snapshots/src/transport/index.ts
diff --git a/packages/core-snapshots/src/transport/verification.ts b/packages/core-snapshots/src/transport/verification.ts
diff --git a/packages/core-snapshots/src/utils.ts b/packages/core-snapshots/src/utils.ts
diff --git a/packages/core-state/src/stores/state.ts b/packages/core-state/src/stores/state.ts
diff --git a/packages/core-state/src/wallets/wallet-manager.ts b/packages/core-state/src/wallets/wallet-manager.ts
diff --git a/packages/core-transaction-pool/src/connection.ts b/packages/core-transaction-pool/src/connection.ts
diff --git a/packages/core-transaction-pool/src/dynamic-fee.ts b/packages/core-transaction-pool/src/dynamic-fee.ts
diff --git a/packages/core-transaction-pool/src/processor.ts b/packages/core-transaction-pool/src/processor.ts
diff --git a/packages/core-transaction-pool/src/service-provider.ts b/packages/core-transaction-pool/src/service-provider.ts
diff --git a/packages/core-wallet-api/src/service-provider.ts b/packages/core-wallet-api/src/service-provider.ts
diff --git a/packages/core-webhooks/src/index.ts b/packages/core-webhooks/src/index.ts
diff --git a/packages/core-webhooks/src/listener.ts b/packages/core-webhooks/src/listener.ts

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ import { Server } from "./server";`
`5`	`5`	`export class ServiceProvider extends Support.AbstractServiceProvider {`
`6`	`6`	`public async register(): Promise<void> {`
`7`	`7`	`if (!this.opts.enabled) {`
`8`		`- this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Public API is disabled");`
	`8`	`+ this.app.resolve<Contracts.Kernel.ILogger>("log").info("Public API is disabled");`
`9`	`9`	`return;`
`10`	`10`	`}`
`11`	`11`
`@@ -18,7 +18,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {`
`18`	`18`
`19`	`19`	`public async dispose(): Promise<void> {`
`20`	`20`	`if (this.opts.enabled) {`
`21`		- this.app.resolve<Contracts.Kernel.ILogger>("logger").info(`Stopping Public API`);
	`21`	+ this.app.resolve<Contracts.Kernel.ILogger>("log").info(`Stopping Public API`);
`22`	`22`
`23`	`23`	`await this.app.resolve<Server>("api").stop();`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ export enum BlockProcessorResult {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`export class BlockProcessor {`
`26`		`- private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("logger");`
	`26`	`+ private readonly logger: Contracts.Kernel.ILogger = app.resolve<Contracts.Kernel.ILogger>("log");`
`27`	`27`
`28`	`28`	`public constructor(private readonly blockchain: Blockchain) {}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ export const tickSyncTracker = (blockCount, count): void => {`
`44`	`44`	`secondsDecimalDigits: 0,`
`45`	`45`	`});`
`46`	`46`
`47`		`- app.resolve<Contracts.Kernel.ILogger>("logger").info(`
	`47`	`+ app.resolve<Contracts.Kernel.ILogger>("log").info(`
`48`	`48`	`Synchronising In Progress (${blocksDownloaded} of ${networkHeight} blocks - Est. ${timeLeft})`,
`49`	`49`	`);`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ import { PostgresConnection } from "./postgres-connection";`
`6`	`6`
`7`	`7`	`export class ServiceProvider extends Support.AbstractServiceProvider {`
`8`	`8`	`public async register(): Promise<void> {`
`9`		`- this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Establishing Database Connection");`
	`9`	`+ this.app.resolve<Contracts.Kernel.ILogger>("log").info("Establishing Database Connection");`
`10`	`10`
`11`	`11`	`const walletManager = new Wallets.WalletManager();`
`12`	`12`
`@@ -17,7 +17,7 @@ export class ServiceProvider extends Support.AbstractServiceProvider {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`public async dispose(): Promise<void> {`
`20`		`- this.app.resolve<Contracts.Kernel.ILogger>("logger").info("Closing Database Connection");`
	`20`	`+ this.app.resolve<Contracts.Kernel.ILogger>("log").info("Closing Database Connection");`
`21`	`21`
`22`	`22`	`await this.app.resolve<Contracts.Database.IDatabaseService>("database").connection.disconnect();`
`23`	`23`	`}`