lavalink-client 2.3.1 → 2.3.3

package/dist/cjs/structures/Types/Manager.d.ts

@@ -1,3 +1,4 @@
+import type { DebugEvents } from "../Constants";
 import type { Player } from "../Player";
 import type { LavalinkNodeOptions } from "./Node";
 import type { DestroyReasonsType, PlayerJson } from "./Player";
@@ -100,6 +101,19 @@ export interface LavalinkManagerEvents {
      * @event Manager#trackError
      */
     "ChaptersLoaded": (player: Player, track: Track | UnresolvedTrack | null, payload: SponsorBlockChaptersLoaded) => void;
+    /**
+     * Lavalink-Client Debug Event
+     * Emitted for several erros, and logs within lavalink-client, if managerOptions.advancedOptions.enableDebugEvents is true
+     * Useful for debugging the lavalink-client
+     *
+     * @event Manager#debug
+     */
+    "debug": (eventKey: DebugEvents, eventData: {
+        message: string;
+        state: "log" | "warn" | "error";
+        error?: Error | string;
+        functionLayer: string;
+    }) => void;
 }
 /**
  * The Bot client Options needed for the manager
@@ -131,6 +145,15 @@ export interface ManagerPlayerOptions {
         /** Instantly destroy player (overrides autoReconnect) | Don't provide == disable feature*/
         destroyPlayer?: boolean;
     };
+    /** Minimum time to play the song before autoPlayFunction is executed (prevents error spamming) Set to 0 to disable it @default 10000 */
+    minAutoPlayMs?: number;
+    /** Allows you to declare how many tracks are allowed to error/stuck within a time-frame before player is destroyed @default "{threshold: 35000, maxAmount: 3 }" */
+    maxErrorsPerTime?: {
+        /** The threshold time to count errors (recommended is 35s) */
+        threshold: number;
+        /** The max amount of errors within the threshold time which are allowed before destroying the player (when errors > maxAmount -> player.destroy()) */
+        maxAmount: number;
+    };
     onEmptyQueue?: {
         /** Get's executed onEmptyQueue -> You can do any track queue previous transformations, if you add a track to the queue -> it will play it, if not queueEnd will execute! */
         autoPlayFunction?: (player: Player, lastPlayedTrack: Track) => Promise<void>;
@@ -166,6 +189,8 @@ export interface ManagerOptions {
     advancedOptions?: {
         /** Max duration for that the filter fix duration works (in ms) - default is 8mins */
         maxFilterFixDuration?: number;
+        /** Enable Debug event */
+        enableDebugEvents?: boolean;
         /** optional */
         debugOptions?: {
             /** For logging custom searches */

package/dist/cjs/structures/Types/Queue.d.ts

@@ -28,7 +28,7 @@ export interface QueueChangesWatcher {
     /** get a Value (MUST RETURN UNPARSED!) */
     tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
     /** Set a value inside a guildId (MUST BE UNPARSED) */
-    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number | number[], oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
     /** Set a value inside a guildId (MUST BE UNPARSED) */
     shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
 }

package/dist/cjs/structures/Utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.queueTrackEnd = exports.MiniMap = exports.ManagerUtils = exports.parseLavalinkConnUrl = exports.NodeSymbol = exports.QueueSymbol = exports.UnresolvedTrackSymbol = exports.TrackSymbol = void 0;
 const node_url_1 = require("node:url");
 const types_1 = require("node:util/types");
+const Constants_1 = require("./Constants");
 const LavalinkManagerStatics_1 = require("./LavalinkManagerStatics");
 exports.TrackSymbol = Symbol("LC-Track");
 exports.UnresolvedTrackSymbol = Symbol("LC-Track-Unresolved");
@@ -75,6 +76,14 @@ class ManagerUtils {
             return r;
         }
         catch (error) {
+            if (this.LavalinkManager?.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager?.emit("debug", Constants_1.DebugEvents.BuildTrackError, {
+                    error: error,
+                    functionLayer: "ManagerUtils > buildTrack()",
+                    message: "Error while building track",
+                    state: "error",
+                });
+            }
             throw new RangeError(`Argument "data" is not a valid track: ${error.message}`);
         }
     }
@@ -133,7 +142,14 @@ class ManagerUtils {
                 : requester;
         }
         catch (e) {
-            console.error("errored while transforming requester:", e);
+            if (this.LavalinkManager?.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager?.emit("debug", Constants_1.DebugEvents.TransformRequesterFunctionFailed, {
+                    error: e,
+                    functionLayer: "ManagerUtils > getTransformedRequester()",
+                    message: "Your custom transformRequesterFunction failed to execute, please check your function for errors.",
+                    state: "error",
+                });
+            }
             return requester;
         }
     }
@@ -199,62 +215,96 @@ class ManagerUtils {
         return typeof data === "object" && !("info" in data) && typeof data.title === "string";
     }
     async getClosestTrack(data, player) {
-        return getClosestTrack(data, player);
+        try {
+            return getClosestTrack(data, player);
+        }
+        catch (e) {
+            if (this.LavalinkManager?.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager?.emit("debug", Constants_1.DebugEvents.GetClosestTrackFailed, {
+                    error: e,
+                    functionLayer: "ManagerUtils > getClosestTrack()",
+                    message: "Failed to resolve track because the getClosestTrack function failed.",
+                    state: "error",
+                });
+            }
+            throw e;
+        }
     }
     validateQueryString(node, queryString, sourceString) {
         if (!node.info)
             throw new Error("No Lavalink Node was provided");
         if (!node.info.sourceManagers?.length)
             throw new Error("Lavalink Node, has no sourceManagers enabled");
+        if (!queryString.trim().length)
+            throw new Error(`Query string is empty, please provide a valid query string.`);
         if (sourceString === "speak" && queryString.length > 100)
-            // checks for blacklisted links / domains / queries
-            if (this.LavalinkManager.options?.linksBlacklist?.length > 0 && this.LavalinkManager.options?.linksBlacklist.some(v => (typeof v === "string" && (queryString.toLowerCase().includes(v.toLowerCase()) || v.toLowerCase().includes(queryString.toLowerCase()))) || (0, types_1.isRegExp)(v) && v.test(queryString))) {
+            throw new Error(`Query is speak, which is limited to 100 characters.`);
+        // checks for blacklisted links / domains / queries
+        if (this.LavalinkManager.options?.linksBlacklist?.length > 0) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", Constants_1.DebugEvents.ValidatingBlacklistLinks, {
+                    state: "log",
+                    message: `Validating Query against LavalinkManager.options.linksBlacklist, query: "${queryString}"`,
+                    functionLayer: "(LavalinkNode > node | player) > search() > validateQueryString()",
+                });
+            }
+            if (this.LavalinkManager.options?.linksBlacklist.some(v => (typeof v === "string" && (queryString.toLowerCase().includes(v.toLowerCase()) || v.toLowerCase().includes(queryString.toLowerCase()))) || (0, types_1.isRegExp)(v) && v.test(queryString))) {
                 throw new Error(`Query string contains a link / word which is blacklisted.`);
             }
+        }
         if (!/^https?:\/\//.test(queryString))
             return;
         else if (this.LavalinkManager.options?.linksAllowed === false)
             throw new Error("Using links to make a request is not allowed.");
         // checks for if the query is whitelisted (should only work for links, so it skips the check for no link queries)
-        if (this.LavalinkManager.options?.linksWhitelist?.length > 0 && !this.LavalinkManager.options?.linksWhitelist.some(v => (typeof v === "string" && (queryString.toLowerCase().includes(v.toLowerCase()) || v.toLowerCase().includes(queryString.toLowerCase()))) || (0, types_1.isRegExp)(v) && v.test(queryString))) {
-            throw new Error(`Query string contains a link / word which isn't whitelisted.`);
+        if (this.LavalinkManager.options?.linksWhitelist?.length > 0) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", Constants_1.DebugEvents.ValidatingWhitelistLinks, {
+                    state: "log",
+                    message: `Link was provided to the Query, validating against LavalinkManager.options.linksWhitelist, query: "${queryString}"`,
+                    functionLayer: "(LavalinkNode > node | player) > search() > validateQueryString()",
+                });
+            }
+            if (!this.LavalinkManager.options?.linksWhitelist.some(v => (typeof v === "string" && (queryString.toLowerCase().includes(v.toLowerCase()) || v.toLowerCase().includes(queryString.toLowerCase()))) || (0, types_1.isRegExp)(v) && v.test(queryString))) {
+                throw new Error(`Query string contains a link / word which isn't whitelisted.`);
+            }
         }
         // missing links: beam.pro local getyarn.io clypit pornhub reddit ocreamix soundgasm
         if ((LavalinkManagerStatics_1.SourceLinksRegexes.YoutubeMusicRegex.test(queryString) || LavalinkManagerStatics_1.SourceLinksRegexes.YoutubeRegex.test(queryString)) && !node.info?.sourceManagers?.includes("youtube")) {
-            throw new Error("Lavalink Node has not 'youtube' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'youtube' enabled");
         }
         if ((LavalinkManagerStatics_1.SourceLinksRegexes.SoundCloudMobileRegex.test(queryString) || LavalinkManagerStatics_1.SourceLinksRegexes.SoundCloudRegex.test(queryString)) && !node.info?.sourceManagers?.includes("soundcloud")) {
-            throw new Error("Lavalink Node has not 'soundcloud' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'soundcloud' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.bandcamp.test(queryString) && !node.info?.sourceManagers?.includes("bandcamp")) {
-            throw new Error("Lavalink Node has not 'bandcamp' enabled (introduced with lavaplayer 2.2.0 or lavalink 4.0.6)");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'bandcamp' enabled (introduced with lavaplayer 2.2.0 or lavalink 4.0.6)");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.TwitchTv.test(queryString) && !node.info?.sourceManagers?.includes("twitch")) {
-            throw new Error("Lavalink Node has not 'twitch' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'twitch' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.vimeo.test(queryString) && !node.info?.sourceManagers?.includes("vimeo")) {
-            throw new Error("Lavalink Node has not 'vimeo' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'vimeo' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.tiktok.test(queryString) && !node.info?.sourceManagers?.includes("tiktok")) {
-            throw new Error("Lavalink Node has not 'tiktok' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'tiktok' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.mixcloud.test(queryString) && !node.info?.sourceManagers?.includes("mixcloud")) {
-            throw new Error("Lavalink Node has not 'mixcloud' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'mixcloud' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.AllSpotifyRegex.test(queryString) && !node.info?.sourceManagers?.includes("spotify")) {
-            throw new Error("Lavalink Node has not 'spotify' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'spotify' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.appleMusic.test(queryString) && !node.info?.sourceManagers?.includes("applemusic")) {
-            throw new Error("Lavalink Node has not 'applemusic' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'applemusic' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.AllDeezerRegex.test(queryString) && !node.info?.sourceManagers?.includes("deezer")) {
-            throw new Error("Lavalink Node has not 'deezer' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'deezer' enabled");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.AllDeezerRegex.test(queryString) && node.info?.sourceManagers?.includes("deezer") && !node.info?.sourceManagers?.includes("http")) {
-            throw new Error("Lavalink Node has not 'http' enabled, which is required to have 'deezer' to work");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'http' enabled, which is required to have 'deezer' to work");
         }
         if (LavalinkManagerStatics_1.SourceLinksRegexes.musicYandex.test(queryString) && !node.info?.sourceManagers?.includes("yandexmusic")) {
-            throw new Error("Lavalink Node has not 'yandexmusic' enabled");
+            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'yandexmusic' enabled");
         }
         return;
     }

package/dist/esm/structures/Constants.d.ts

@@ -1,4 +1,45 @@
 import type { AudioOutputs, ChannelMixFilter, EQBand } from "./Types/Filters";
+export declare enum DebugEvents {
+    SetSponsorBlock = "SetSponsorBlock",
+    DeleteSponsorBlock = "DeleteSponsorBlock",
+    TrackEndReplaced = "TrackEndReplaced",
+    AutoplayNoSongsAdded = "AutoplayNoSongsAdded",
+    AutoplayThresholdSpamLimiter = "AutoplayThresholdSpamLimiter",
+    TriggerQueueEmptyInterval = "TriggerQueueEmptyInterval",
+    QueueEnded = "QueueEnded",
+    TrackStartNewSongsOnly = "TrackStartNewSongsOnly",
+    TrackStartNoTrack = "TrackStartNoTrack",
+    ResumingFetchingError = "ResumingFetchingError",
+    PlayerUpdateNoPlayer = "PlayerUpdateNoPlayer",
+    PlayerUpdateFilterFixApply = "PlayerUpdateFilterFixApply",
+    PlayerUpdateSuccess = "PlayerUpdateSuccess",
+    HeartBeatTriggered = "HeartBeatTriggered",
+    NoSocketOnDestroy = "NoSocketOnDestroy",
+    SocketTerminateHeartBeatTimeout = "SocketTerminateHeartBeatTimeout",
+    TryingConnectWhileConnected = "TryingConnectWhileConnected",
+    LavaSearchNothingFound = "LavaSearchNothingFound",
+    SearchNothingFound = "SearchNothingFound",
+    ValidatingBlacklistLinks = "ValidatingBlacklistLinks",
+    ValidatingWhitelistLinks = "ValidatingWhitelistLinks",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime",
+    PlayerDestroyingSomewhereElse = "PlayerDestroyingSomewhereElse",
+    PlayerCreateNodeNotFound = "PlayerCreateNodeNotFound",
+    PlayerPlayQueueEmptyTimeoutClear = "PlayerPlayQueueEmptyTimeoutClear",
+    PlayerPlayWithTrackReplace = "PlayerPlayWithTrackReplace",
+    PlayerPlayUnresolvedTrack = "PlayerPlayUnresolvedTrack",
+    PlayerPlayUnresolvedTrackFailed = "PlayerPlayUnresolvedTrackFailed",
+    PlayerVolumeAsFilter = "PlayerVolumeAsFilter",
+    BandcampSearchLokalEngine = "BandcampSearchLokalEngine",
+    PlayerChangeNode = "PlayerChangeNode",
+    BuildTrackError = "BuildTrackError",
+    TransformRequesterFunctionFailed = "TransformRequesterFunctionFailed",
+    GetClosestTrackFailed = "GetClosestTrackFailed",
+    PlayerDeleteInsteadOfDestroy = "PlayerDeleteInsteadOfDestroy",
+    FailedToConnectToNodes = "FailedToConnectToNodes",
+    NoAudioDebug = "NoAudioDebug",
+    PlayerAutoReconnect = "PlayerAutoReconnect"
+}
 export declare enum DestroyReasons {
     QueueEmpty = "QueueEmpty",
     NodeDestroy = "NodeDestroy",
@@ -9,7 +50,9 @@ export declare enum DestroyReasons {
     PlayerReconnectFail = "PlayerReconnectFail",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
-    ReconnectAllNodes = "ReconnectAllNodes"
+    ReconnectAllNodes = "ReconnectAllNodes",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime"
 }
 export declare const validSponsorBlocks: string[];
 /**  The audio Outputs Data map declaration */

package/dist/esm/structures/Constants.js

@@ -1,3 +1,45 @@
+export var DebugEvents;
+(function (DebugEvents) {
+    DebugEvents["SetSponsorBlock"] = "SetSponsorBlock";
+    DebugEvents["DeleteSponsorBlock"] = "DeleteSponsorBlock";
+    DebugEvents["TrackEndReplaced"] = "TrackEndReplaced";
+    DebugEvents["AutoplayNoSongsAdded"] = "AutoplayNoSongsAdded";
+    DebugEvents["AutoplayThresholdSpamLimiter"] = "AutoplayThresholdSpamLimiter";
+    DebugEvents["TriggerQueueEmptyInterval"] = "TriggerQueueEmptyInterval";
+    DebugEvents["QueueEnded"] = "QueueEnded";
+    DebugEvents["TrackStartNewSongsOnly"] = "TrackStartNewSongsOnly";
+    DebugEvents["TrackStartNoTrack"] = "TrackStartNoTrack";
+    DebugEvents["ResumingFetchingError"] = "ResumingFetchingError";
+    DebugEvents["PlayerUpdateNoPlayer"] = "PlayerUpdateNoPlayer";
+    DebugEvents["PlayerUpdateFilterFixApply"] = "PlayerUpdateFilterFixApply";
+    DebugEvents["PlayerUpdateSuccess"] = "PlayerUpdateSuccess";
+    DebugEvents["HeartBeatTriggered"] = "HeartBeatTriggered";
+    DebugEvents["NoSocketOnDestroy"] = "NoSocketOnDestroy";
+    DebugEvents["SocketTerminateHeartBeatTimeout"] = "SocketTerminateHeartBeatTimeout";
+    DebugEvents["TryingConnectWhileConnected"] = "TryingConnectWhileConnected";
+    DebugEvents["LavaSearchNothingFound"] = "LavaSearchNothingFound";
+    DebugEvents["SearchNothingFound"] = "SearchNothingFound";
+    DebugEvents["ValidatingBlacklistLinks"] = "ValidatingBlacklistLinks";
+    DebugEvents["ValidatingWhitelistLinks"] = "ValidatingWhitelistLinks";
+    DebugEvents["TrackErrorMaxTracksErroredPerTime"] = "TrackErrorMaxTracksErroredPerTime";
+    DebugEvents["TrackStuckMaxTracksErroredPerTime"] = "TrackStuckMaxTracksErroredPerTime";
+    DebugEvents["PlayerDestroyingSomewhereElse"] = "PlayerDestroyingSomewhereElse";
+    DebugEvents["PlayerCreateNodeNotFound"] = "PlayerCreateNodeNotFound";
+    DebugEvents["PlayerPlayQueueEmptyTimeoutClear"] = "PlayerPlayQueueEmptyTimeoutClear";
+    DebugEvents["PlayerPlayWithTrackReplace"] = "PlayerPlayWithTrackReplace";
+    DebugEvents["PlayerPlayUnresolvedTrack"] = "PlayerPlayUnresolvedTrack";
+    DebugEvents["PlayerPlayUnresolvedTrackFailed"] = "PlayerPlayUnresolvedTrackFailed";
+    DebugEvents["PlayerVolumeAsFilter"] = "PlayerVolumeAsFilter";
+    DebugEvents["BandcampSearchLokalEngine"] = "BandcampSearchLokalEngine";
+    DebugEvents["PlayerChangeNode"] = "PlayerChangeNode";
+    DebugEvents["BuildTrackError"] = "BuildTrackError";
+    DebugEvents["TransformRequesterFunctionFailed"] = "TransformRequesterFunctionFailed";
+    DebugEvents["GetClosestTrackFailed"] = "GetClosestTrackFailed";
+    DebugEvents["PlayerDeleteInsteadOfDestroy"] = "PlayerDeleteInsteadOfDestroy";
+    DebugEvents["FailedToConnectToNodes"] = "FailedToConnectToNodes";
+    DebugEvents["NoAudioDebug"] = "NoAudioDebug";
+    DebugEvents["PlayerAutoReconnect"] = "PlayerAutoReconnect";
+})(DebugEvents || (DebugEvents = {}));
 export var DestroyReasons;
 (function (DestroyReasons) {
     DestroyReasons["QueueEmpty"] = "QueueEmpty";
@@ -10,6 +52,8 @@ export var DestroyReasons;
     DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
     DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
     DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";
+    DestroyReasons["TrackErrorMaxTracksErroredPerTime"] = "TrackErrorMaxTracksErroredPerTime";
+    DestroyReasons["TrackStuckMaxTracksErroredPerTime"] = "TrackStuckMaxTracksErroredPerTime";
 })(DestroyReasons || (DestroyReasons = {}));
 ;
 export const validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];

package/dist/esm/structures/LavalinkManager.js

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import { DestroyReasons } from "./Constants";
+import { DebugEvents, DestroyReasons } from "./Constants";
 import { NodeManager } from "./NodeManager";
 import { Player } from "./Player";
 import { DefaultQueueStore } from "./Queue";
@@ -89,9 +89,15 @@ export class LavalinkManager extends EventEmitter {
                 volumeDecrementer: options?.playerOptions?.volumeDecrementer ?? 1,
                 requesterTransformer: options?.playerOptions?.requesterTransformer ?? null,
                 useUnresolvedData: options?.playerOptions?.useUnresolvedData ?? false,
+                minAutoPlayMs: options?.playerOptions?.minAutoPlayMs ?? 10000,
+                maxErrorsPerTime: {
+                    threshold: options?.playerOptions?.maxErrorsPerTime?.threshold ?? 35000,
+                    maxAmount: options?.playerOptions?.maxErrorsPerTime?.maxAmount ?? 3
+                }
             },
             linksWhitelist: options?.linksWhitelist ?? [],
             linksBlacklist: options?.linksBlacklist ?? [],
+            linksAllowed: options?.linksAllowed ?? true,
             autoSkip: options?.autoSkip ?? true,
             autoSkipOnResolveError: options?.autoSkipOnResolveError ?? true,
             emitNewSongsOnly: options?.emitNewSongsOnly ?? false,
@@ -101,6 +107,7 @@ export class LavalinkManager extends EventEmitter {
                 queueStore: options?.queueOptions?.queueStore ?? new DefaultQueueStore(),
             },
             advancedOptions: {
+                enableDebugEvents: options?.advancedOptions?.enableDebugEvents ?? false,
                 maxFilterFixDuration: options?.advancedOptions?.maxFilterFixDuration ?? 600000,
                 debugOptions: {
                     logCustomSearches: options?.advancedOptions?.debugOptions?.logCustomSearches ?? false,
@@ -304,8 +311,13 @@ export class LavalinkManager extends EventEmitter {
         if (oldPlayer.voiceChannelId === "string" && oldPlayer.connected && !oldPlayer.get("internal_destroywithoutdisconnect")) {
             if (!this.options?.advancedOptions?.debugOptions?.playerDestroy?.dontThrowError)
                 throw new Error(`Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player ${JSON.stringify(oldPlayer.toJSON?.())}`);
-            else
-                console.error("Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player", oldPlayer.toJSON?.());
+            else if (this.options?.advancedOptions?.enableDebugEvents) {
+                this.emit("debug", DebugEvents.PlayerDeleteInsteadOfDestroy, {
+                    state: "warn",
+                    message: "Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player",
+                    functionLayer: "LavalinkManager > deletePlayer()",
+                });
+            }
         }
         return this.players.delete(guildId);
     }
@@ -358,8 +370,13 @@ export class LavalinkManager extends EventEmitter {
         }
         if (success > 0)
             this.initiated = true;
-        else
-            console.error("Could not connect to at least 1 Node");
+        else if (this.options?.advancedOptions?.enableDebugEvents) {
+            this.emit("debug", DebugEvents.FailedToConnectToNodes, {
+                state: "error",
+                message: "Failed to connect to at least 1 Node",
+                functionLayer: "LavalinkManager > init()",
+            });
+        }
         return this;
     }
     /**
@@ -379,11 +396,25 @@ export class LavalinkManager extends EventEmitter {
      */
     async sendRawData(data) {
         if (!this.initiated) {
+            if (this.options?.advancedOptions?.enableDebugEvents) {
+                this.emit("debug", DebugEvents.NoAudioDebug, {
+                    state: "log",
+                    message: "Manager is not initated yet",
+                    functionLayer: "LavalinkManager > sendRawData()",
+                });
+            }
             if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                 console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, manager is not initated yet");
             return;
         }
         if (!("t" in data)) {
+            if (this.options?.advancedOptions?.enableDebugEvents) {
+                this.emit("debug", DebugEvents.NoAudioDebug, {
+                    state: "error",
+                    message: "No 't' in payload-data of the raw event:",
+                    functionLayer: "LavalinkManager > sendRawData()",
+                });
+            }
             if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                 console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no 't' in payload-data of the raw event:", data);
             return;
@@ -401,22 +432,50 @@ export class LavalinkManager extends EventEmitter {
         if (["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(data.t)) {
             const update = ("d" in data ? data.d : data);
             if (!update) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", DebugEvents.NoAudioDebug, {
+                        state: "warn",
+                        message: `No Update data found in payload :: ${JSON.stringify(data, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no update data found in payload:", data);
                 return;
             }
             if (!("token" in update) && !("session_id" in update)) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", DebugEvents.NoAudioDebug, {
+                        state: "error",
+                        message: `No 'token' nor 'session_id' found in payload :: ${JSON.stringify(data, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no 'token' nor 'session_id' found in payload:", data);
                 return;
             }
             const player = this.getPlayer(update.guild_id);
             if (!player) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", DebugEvents.NoAudioDebug, {
+                        state: "warn",
+                        message: `No Lavalink Player found via key: 'guild_id' of update-data :: ${JSON.stringify(update, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, No Lavalink Player found via key: 'guild_id' of update-data:", update);
                 return;
             }
             if (player.get("internal_destroystatus") === true) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", DebugEvents.NoAudioDebug, {
+                        state: "warn",
+                        message: `Player is in a destroying state. can't signal the voice states`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, Player is in a destroying state. can't signal the voice states");
                 return;
@@ -434,12 +493,24 @@ export class LavalinkManager extends EventEmitter {
                         }
                     }
                 });
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", DebugEvents.NoAudioDebug, {
+                        state: "log",
+                        message: `Sent updatePlayer for voice token session :: ${JSON.stringify({ voice: { token: update.token, endpoint: update.endpoint, sessionId: player.voice?.sessionId, }, update }, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, Sent updatePlayer for voice token session", { voice: { token: update.token, endpoint: update.endpoint, sessionId: player.voice?.sessionId, } });
                 return;
             }
             /* voice state update */
             if (update.user_id !== this.options?.client.id) {
+                this.emit("debug", DebugEvents.NoAudioDebug, {
+                    state: "warn",
+                    message: `voice update user is not equal to provided client id of the LavalinkManager.options.client.id :: user: "${update.user_id}" manager client id: "${this.options?.client.id}"`,
+                    functionLayer: "LavalinkManager > sendRawData()",
+                });
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, voice update user is not equal to provided client id of the manageroptions#client#id", "user:", update.user_id, "manager client id:", this.options?.client.id);
                 return;
@@ -458,7 +529,11 @@ export class LavalinkManager extends EventEmitter {
                 if (this.options?.playerOptions?.onDisconnect?.autoReconnect === true) {
                     try {
                         const positionPrevios = player.position;
-                        console.debug("Auto reconnect", positionPrevios, player.lastPosition);
+                        this.emit("debug", DebugEvents.PlayerAutoReconnect, {
+                            state: "log",
+                            message: `Auto reconnecting player because LavalinkManager.options.playerOptions.onDisconnect.autoReconnect is true`,
+                            functionLayer: "LavalinkManager > sendRawData()",
+                        });
                         await player.connect();
                         // replay the current playing stream
                         await player.play({