CopyBot/Red-DiscordBot
1
0
Fork 0
mirror of https://github.com/Cog-Creators/Red-DiscordBot.git synced 2025-11-06 03:08:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

Bump RLL and improve logging (#5044)

Browse Source 
* version bump

* - bump RLL
- logging changes
- player.channel.guild->player.guild
- small cleanup around logging changes

* missed one

* here this one too

* Apply suggestions from code review

Co-authored-by: jack1142 <6032823+jack1142@users.noreply.github.com>

* add one missing player log

* missed one

* Format with Black

Co-authored-by: jack1142 <6032823+jack1142@users.noreply.github.com>
This commit is contained in:
Draper 2021-05-18 23:56:10 +01:00 committed by GitHub
parent c9431f7d90
commit 38da7370ec
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 164 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
redbot/cogs/audio/apis/global_db.py
View File

@ -78,14 +78,16 @@ class GlobalCacheWrapper:
search_response = await r.json(loads=json.loads) search_response = await r.json(loads=json.loads)
if IS_DEBUG and "x-process-time" in r.headers: if IS_DEBUG and "x-process-time" in r.headers:
log.debug( log.debug(
f"GET || Ping {r.headers.get('x-process-time')} || " "GET || Ping %s || Status code %d || %s",
f"Status code {r.status} || {query}" r.headers.get("x-process-time"),
r.status,
query,
) )
if "tracks" not in search_response: if "tracks" not in search_response:
return {} return {}
return search_response return search_response
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Failed to Get query: {api_url}/{query}") debug_exc_log(log, err, "Failed to Get query: %s/%s", api_url, query)
return {} return {}
async def get_spotify(self, title: str, author: Optional[str]) -> dict: async def get_spotify(self, title: str, author: Optional[str]) -> dict:
@ -108,14 +110,17 @@ class GlobalCacheWrapper:
search_response = await r.json(loads=json.loads) search_response = await r.json(loads=json.loads)
if IS_DEBUG and "x-process-time" in r.headers: if IS_DEBUG and "x-process-time" in r.headers:
log.debug( log.debug(
f"GET/spotify || Ping {r.headers.get('x-process-time')} || " "GET/spotify || Ping %s || Status code %d || %s - %s",
f"Status code {r.status} || {title} - {author}" r.headers.get("x-process-time"),
r.status,
title,
author,
) )
if "tracks" not in search_response: if "tracks" not in search_response:
return {} return {}
return search_response return search_response
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Failed to Get query: {api_url}") debug_exc_log(log, err, "Failed to Get query: %s", api_url)
return {} return {}
async def post_call(self, llresponse: LoadResult, query: Optional[Query]) -> None: async def post_call(self, llresponse: LoadResult, query: Optional[Query]) -> None:
@ -142,11 +147,13 @@ class GlobalCacheWrapper:
await r.read() await r.read()
if IS_DEBUG and "x-process-time" in r.headers: if IS_DEBUG and "x-process-time" in r.headers:
log.debug( log.debug(
f"POST || Ping {r.headers.get('x-process-time')} ||" "GET || Ping %s || Status code %d || %s",
f" Status code {r.status} || {query}" r.headers.get("x-process-time"),
r.status,
query,
) )
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Failed to post query: {query}") debug_exc_log(log, err, "Failed to post query: %s", query)
await asyncio.sleep(0) await asyncio.sleep(0)
async def update_global(self, llresponse: LoadResult, query: Optional[Query] = None): async def update_global(self, llresponse: LoadResult, query: Optional[Query] = None):

60
redbot/cogs/audio/apis/interface.py
View File

@ -149,7 +149,7 @@ class AudioAPIInterface:
async with self._lock: async with self._lock:
if lock_id in self._tasks: if lock_id in self._tasks:
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Running database writes for {lock_id} ({lock_author})") log.debug("Running database writes for %d (%s)", lock_id, lock_author)
try: try:
tasks = self._tasks[lock_id] tasks = self._tasks[lock_id]
tasks = [self.route_tasks(a, tasks[a]) for a in tasks] tasks = [self.route_tasks(a, tasks[a]) for a in tasks]
@ -157,11 +157,11 @@ class AudioAPIInterface:
del self._tasks[lock_id] del self._tasks[lock_id]
except Exception as exc: except Exception as exc:
debug_exc_log( debug_exc_log(
log, exc, f"Failed database writes for {lock_id} ({lock_author})" log, exc, "Failed database writes for %d (%s)", lock_id, lock_author
) )
else: else:
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Completed database writes for {lock_id} ({lock_author})") log.debug("Completed database writes for %d (%s)", lock_id, lock_author)
async def run_all_pending_tasks(self) -> None: async def run_all_pending_tasks(self) -> None:
"""Run all pending tasks left in the cache, called on cog_unload.""" """Run all pending tasks left in the cache, called on cog_unload."""
@ -248,7 +248,9 @@ class AudioAPIInterface:
{"track": track_info} {"track": track_info}
) )
except Exception as exc: except Exception as exc:
debug_exc_log(log, exc, f"Failed to fetch {track_info} from YouTube table") debug_exc_log(
log, exc, "Failed to fetch %r from YouTube table", track_info
)
if val is None: if val is None:
try: try:
@ -386,7 +388,7 @@ class AudioAPIInterface:
) )
except Exception as exc: except Exception as exc:
debug_exc_log( debug_exc_log(
log, exc, f"Failed to fetch 'spotify:track:{uri}' from Spotify table" log, exc, "Failed to fetch 'spotify:track:%s' from Spotify table", uri
) )
val = None val = None
else: else:
@ -513,7 +515,9 @@ class AudioAPIInterface:
{"track": track_info} {"track": track_info}
) )
except Exception as exc: except Exception as exc:
debug_exc_log(log, exc, f"Failed to fetch {track_info} from YouTube table") debug_exc_log(
log, exc, "Failed to fetch %r from YouTube table", track_info
)
should_query_global = globaldb_toggle and query_global and val is None should_query_global = globaldb_toggle and query_global and val is None
if should_query_global: if should_query_global:
llresponse = await self.global_cache_api.get_spotify(track_name, artist_name) llresponse = await self.global_cache_api.get_spotify(track_name, artist_name)
@ -621,7 +625,7 @@ class AudioAPIInterface:
): ):
has_not_allowed = True has_not_allowed = True
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Query is not allowed in {ctx.guild} ({ctx.guild.id})") log.debug("Query is not allowed in %r (%d)", ctx.guild.name, ctx.guild.id)
continue continue
track_list.append(single_track) track_list.append(single_track)
if enqueue: if enqueue:
@ -640,7 +644,7 @@ class AudioAPIInterface:
player.add(ctx.author, single_track) player.add(ctx.author, single_track)
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", "red_audio_track_enqueue",
player.channel.guild, player.guild,
single_track, single_track,
ctx.author, ctx.author,
) )
@ -656,7 +660,7 @@ class AudioAPIInterface:
player.add(ctx.author, single_track) player.add(ctx.author, single_track)
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", "red_audio_track_enqueue",
player.channel.guild, player.guild,
single_track, single_track,
ctx.author, ctx.author,
) )
@ -748,7 +752,7 @@ class AudioAPIInterface:
try: try:
(val, update) = await self.local_cache_api.youtube.fetch_one({"track": track_info}) (val, update) = await self.local_cache_api.youtube.fetch_one({"track": track_info})
except Exception as exc: except Exception as exc:
debug_exc_log(log, exc, f"Failed to fetch {track_info} from YouTube table") debug_exc_log(log, exc, "Failed to fetch %r from YouTube table", track_info)
if val is None: if val is None:
try: try:
youtube_url = await self.fetch_youtube_query( youtube_url = await self.fetch_youtube_query(
@ -813,11 +817,11 @@ class AudioAPIInterface:
{"query": query_string} {"query": query_string}
) )
except Exception as exc: except Exception as exc:
debug_exc_log(log, exc, f"Failed to fetch '{query_string}' from Lavalink table") debug_exc_log(log, exc, "Failed to fetch %r from Lavalink table", query_string)
if val and isinstance(val, dict): if val and isinstance(val, dict):
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Updating Local Database with {query_string}") log.debug("Updating Local Database with %r", query_string)
task = ("update", ("lavalink", {"query": query_string})) task = ("update", ("lavalink", {"query": query_string}))
self.append_task(ctx, *task) self.append_task(ctx, *task)
else: else:
@ -851,7 +855,7 @@ class AudioAPIInterface:
valid_global_entry = True valid_global_entry = True
if valid_global_entry: if valid_global_entry:
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Querying Global DB api for {query}") log.debug("Querying Global DB api for %r", query)
results, called_api = results, False results, called_api = results, False
if valid_global_entry: if valid_global_entry:
pass pass
@ -870,7 +874,7 @@ class AudioAPIInterface:
valid_global_entry = False valid_global_entry = False
else: else:
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Querying Lavalink api for {query_string}") log.debug("Querying Lavalink api for %r", query_string)
called_api = True called_api = True
try: try:
results = await player.load_tracks(query_string) results = await player.load_tracks(query_string)
@ -923,13 +927,14 @@ class AudioAPIInterface:
debug_exc_log( debug_exc_log(
log, log,
exc, exc,
f"Failed to enqueue write task for '{query_string}' to Lavalink table", "Failed to enqueue write task for %r to Lavalink table",
query_string,
) )
return results, called_api return results, called_api
async def autoplay(self, player: lavalink.Player, playlist_api: PlaylistWrapper): async def autoplay(self, player: lavalink.Player, playlist_api: PlaylistWrapper):
"""Enqueue a random track.""" """Enqueue a random track."""
autoplaylist = await self.config.guild(player.channel.guild).autoplaylist() autoplaylist = await self.config.guild(player.guild).autoplaylist()
current_cache_level = CacheLevel(await self.config.cache_level()) current_cache_level = CacheLevel(await self.config.cache_level())
cache_enabled = CacheLevel.set_lavalink().is_subset(current_cache_level) cache_enabled = CacheLevel.set_lavalink().is_subset(current_cache_level)
notify_channel_id = player.fetch("channel") notify_channel_id = player.fetch("channel")
@ -942,8 +947,8 @@ class AudioAPIInterface:
autoplaylist["scope"], autoplaylist["scope"],
self.bot, self.bot,
playlist_api, playlist_api,
player.channel.guild, player.guild,
player.channel.guild.me, player.guild.me,
) )
tracks = playlist.tracks_obj tracks = playlist.tracks_obj
except Exception as exc: except Exception as exc:
@ -956,9 +961,7 @@ class AudioAPIInterface:
if not tracks: if not tracks:
ctx = namedtuple("Context", "message guild cog") ctx = namedtuple("Context", "message guild cog")
(results, called_api) = await self.fetch_track( (results, called_api) = await self.fetch_track(
cast( cast(commands.Context, ctx(player.guild, player.guild, self.cog)),
commands.Context, ctx(player.channel.guild, player.channel.guild, self.cog)
),
player, player,
Query.process_input(_TOP_100_US, self.cog.local_folder_current_path), Query.process_input(_TOP_100_US, self.cog.local_folder_current_path),
) )
@ -990,8 +993,7 @@ class AudioAPIInterface:
): ):
if IS_DEBUG: if IS_DEBUG:
log.debug( log.debug(
"Query is not allowed in " "Query is not allowed in %r (%d)", player.guild.name, player.guild.id
f"{player.channel.guild} ({player.channel.guild.id})"
) )
continue continue
valid = True valid = True
@ -1000,24 +1002,24 @@ class AudioAPIInterface:
"autoplay": True, "autoplay": True,
"enqueue_time": int(time.time()), "enqueue_time": int(time.time()),
"vc": player.channel.id, "vc": player.channel.id,
"requester": player.channel.guild.me.id, "requester": player.guild.me.id,
} }
) )
player.add(player.channel.guild.me, track) player.add(player.guild.me, track)
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_auto_play", "red_audio_track_auto_play",
player.channel.guild, player.guild,
track, track,
player.channel.guild.me, player.guild.me,
player, player,
) )
if notify_channel_id: if notify_channel_id:
await self.config.guild_from_id( await self.config.guild_from_id(
guild_id=player.channel.guild.id guild_id=player.guild.id
).currently_auto_playing_in.set([notify_channel_id, player.channel.id]) ).currently_auto_playing_in.set([notify_channel_id, player.channel.id])
else: else:
await self.config.guild_from_id( await self.config.guild_from_id(
guild_id=player.channel.guild.id guild_id=player.guild.id
).currently_auto_playing_in.set([]) ).currently_auto_playing_in.set([])
if not player.current: if not player.current:
await player.play() await player.play()

6
redbot/cogs/audio/apis/spotify.py
View File

@ -102,7 +102,7 @@ class SpotifyWrapper:
async with self.session.request("GET", url, params=params, headers=headers) as r: async with self.session.request("GET", url, params=params, headers=headers) as r:
data = await r.json(loads=json.loads) data = await r.json(loads=json.loads)
if r.status != 200: if r.status != 200:
log.debug(f"Issue making GET request to {url}: [{r.status}] {data}") log.debug("Issue making GET request to %r: [%d] %r", url, r.status, data)
return data return data
async def update_token(self, new_token: Mapping[str, str]): async def update_token(self, new_token: Mapping[str, str]):
@ -146,7 +146,7 @@ class SpotifyWrapper:
except KeyError: except KeyError:
return None return None
self.spotify_token = token self.spotify_token = token
log.debug(f"Created a new access token for Spotify: {token}") log.debug("Created a new access token for Spotify: %s", token)
return self.spotify_token["access_token"] return self.spotify_token["access_token"]
async def post( async def post(
@ -156,7 +156,7 @@ class SpotifyWrapper:
async with self.session.post(url, data=payload, headers=headers) as r: async with self.session.post(url, data=payload, headers=headers) as r:
data = await r.json(loads=json.loads) data = await r.json(loads=json.loads)
if r.status != 200: if r.status != 200:
log.debug(f"Issue making POST request to {url}: [{r.status}] {data}") log.debug("Issue making POST request to %r: [%d] %r", url, r.status, data)
return data return data
async def make_get_call(self, url: str, params: MutableMapping) -> MutableMapping: async def make_get_call(self, url: str, params: MutableMapping) -> MutableMapping:

6
redbot/cogs/audio/audio_logging.py
View File

@ -1,7 +1,7 @@
import logging import logging
import sys import sys
from typing import Final from typing import Final, Any, Tuple
IS_DEBUG: Final[bool] = "--debug" in sys.argv IS_DEBUG: Final[bool] = "--debug" in sys.argv
@ -10,9 +10,9 @@ def is_debug() -> bool:
return IS_DEBUG return IS_DEBUG
def debug_exc_log(lg: logging.Logger, exc: Exception, msg: str = None) -> None: def debug_exc_log(lg: logging.Logger, exc: Exception, msg: str = None, *args: Tuple[Any]) -> None:
"""Logs an exception if logging is set to DEBUG level""" """Logs an exception if logging is set to DEBUG level"""
if lg.getEffectiveLevel() <= logging.DEBUG: if lg.getEffectiveLevel() <= logging.DEBUG:
if msg is None: if msg is None:
msg = f"{exc}" msg = f"{exc}"
lg.exception(msg, exc_info=exc) lg.exception(msg, *args, exc_info=exc)

2
redbot/cogs/audio/core/commands/controller.py
View File

@ -289,7 +289,7 @@ class PlayerControllerCommands(MixinMeta, metaclass=CompositeMetaClass):
} }
) )
player.add(player.fetch("prev_requester"), track) player.add(player.fetch("prev_requester"), track)
self.bot.dispatch("red_audio_track_enqueue", player.channel.guild, track, ctx.author) self.bot.dispatch("red_audio_track_enqueue", player.guild, track, ctx.author)
queue_len = len(player.queue) queue_len = len(player.queue)
bump_song = player.queue[-1] bump_song = player.queue[-1]
player.queue.insert(0, bump_song) player.queue.insert(0, bump_song)

4
redbot/cogs/audio/core/commands/miscellaneous.py
View File

@ -59,10 +59,10 @@ class MiscellaneousCommands(MixinMeta, metaclass=CompositeMetaClass):
current_title = await self.get_track_description( current_title = await self.get_track_description(
p.current, self.local_folder_current_path p.current, self.local_folder_current_path
) )
msg += "{} [`{}`]: {}\n".format(p.channel.guild.name, connect_dur, current_title) msg += "{} [`{}`]: {}\n".format(p.guild.name, connect_dur, current_title)
except AttributeError: except AttributeError:
msg += "{} [`{}`]: **{}**\n".format( msg += "{} [`{}`]: **{}**\n".format(
p.channel.guild.name, connect_dur, _("Nothing playing.") p.guild.name, connect_dur, _("Nothing playing.")
) )
if total_num == 0: if total_num == 0:

16
redbot/cogs/audio/core/commands/player.py
View File

@ -294,7 +294,7 @@ class PlayerCommands(MixinMeta, metaclass=CompositeMetaClass):
query_obj=query, query_obj=query,
): ):
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Query is not allowed in {ctx.guild} ({ctx.guild.id})") log.debug("Query is not allowed in %r (%d)", ctx.guild.name, ctx.guild.id)
self.update_player_lock(ctx, False) self.update_player_lock(ctx, False)
return await self.send_embed_msg( return await self.send_embed_msg(
ctx, ctx,
@ -314,7 +314,7 @@ class PlayerCommands(MixinMeta, metaclass=CompositeMetaClass):
player.queue.insert(0, single_track) player.queue.insert(0, single_track)
player.maybe_shuffle() player.maybe_shuffle()
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", player.channel.guild, single_track, ctx.author "red_audio_track_enqueue", player.guild, single_track, ctx.author
) )
else: else:
self.update_player_lock(ctx, False) self.update_player_lock(ctx, False)
@ -336,9 +336,7 @@ class PlayerCommands(MixinMeta, metaclass=CompositeMetaClass):
) )
player.queue.insert(0, single_track) player.queue.insert(0, single_track)
player.maybe_shuffle() player.maybe_shuffle()
self.bot.dispatch( self.bot.dispatch("red_audio_track_enqueue", player.guild, single_track, ctx.author)
"red_audio_track_enqueue", player.channel.guild, single_track, ctx.author
)
description = await self.get_track_description( description = await self.get_track_description(
single_track, self.local_folder_current_path single_track, self.local_folder_current_path
) )
@ -838,7 +836,9 @@ class PlayerCommands(MixinMeta, metaclass=CompositeMetaClass):
query_obj=query, query_obj=query,
): ):
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Query is not allowed in {ctx.guild} ({ctx.guild.id})") log.debug(
"Query is not allowed in %r (%d)", ctx.guild.name, ctx.guild.id
)
continue continue
elif guild_data["maxlength"] > 0: elif guild_data["maxlength"] > 0:
if self.is_track_length_allowed(track, guild_data["maxlength"]): if self.is_track_length_allowed(track, guild_data["maxlength"]):
@ -852,7 +852,7 @@ class PlayerCommands(MixinMeta, metaclass=CompositeMetaClass):
) )
player.add(ctx.author, track) player.add(ctx.author, track)
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", player.channel.guild, track, ctx.author "red_audio_track_enqueue", player.guild, track, ctx.author
) )
else: else:
track_len += 1 track_len += 1
@ -865,7 +865,7 @@ class PlayerCommands(MixinMeta, metaclass=CompositeMetaClass):
) )
player.add(ctx.author, track) player.add(ctx.author, track)
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", player.channel.guild, track, ctx.author "red_audio_track_enqueue", player.guild, track, ctx.author
) )
if not player.current: if not player.current:
await player.play() await player.play()

8
redbot/cogs/audio/core/commands/playlists.py
View File

@ -1525,7 +1525,9 @@ class PlaylistCommands(MixinMeta, metaclass=CompositeMetaClass):
query_obj=query, query_obj=query,
): ):
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Query is not allowed in {ctx.guild} ({ctx.guild.id})") log.debug(
"Query is not allowed in %r (%d)", ctx.guild.name, ctx.guild.id
)
continue continue
query = Query.process_input(track.uri, self.local_folder_current_path) query = Query.process_input(track.uri, self.local_folder_current_path)
if query.is_local: if query.is_local:
@ -1544,9 +1546,7 @@ class PlaylistCommands(MixinMeta, metaclass=CompositeMetaClass):
} }
) )
player.add(author_obj, track) player.add(author_obj, track)
self.bot.dispatch( self.bot.dispatch("red_audio_track_enqueue", player.guild, track, ctx.author)
"red_audio_track_enqueue", player.channel.guild, track, ctx.author
)
track_len += 1 track_len += 1
player.maybe_shuffle(0 if empty_queue else 1) player.maybe_shuffle(0 if empty_queue else 1)
if len(tracks) > track_len: if len(tracks) > track_len:

6
redbot/cogs/audio/core/events/cog.py
View File

@ -124,7 +124,7 @@ class AudioEvents(MixinMeta, metaclass=CompositeMetaClass):
bot=self.bot, bot=self.bot,
) )
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Failed to delete daily playlist ID: {too_old_id}") debug_exc_log(log, err, "Failed to delete daily playlist ID: %d", too_old_id)
try: try:
await delete_playlist( await delete_playlist(
scope=PlaylistScope.GLOBAL.value, scope=PlaylistScope.GLOBAL.value,
@ -135,7 +135,9 @@ class AudioEvents(MixinMeta, metaclass=CompositeMetaClass):
bot=self.bot, bot=self.bot,
) )
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Failed to delete global daily playlist ID: {too_old_id}") debug_exc_log(
log, err, "Failed to delete global daily playlist ID: %d", too_old_id
)
persist_cache = self._persist_queue_cache.setdefault( persist_cache = self._persist_queue_cache.setdefault(
guild.id, await self.config.guild(guild).persist_queue() guild.id, await self.config.guild(guild).persist_queue()
) )

14
redbot/cogs/audio/core/events/dpy.py
View File

@ -263,20 +263,6 @@ class DpyEvents(MixinMeta, metaclass=CompositeMetaClass):
except (ValueError, KeyError, AttributeError): except (ValueError, KeyError, AttributeError):
pass pass
# if (
# member == member.guild.me
# and before.channel
# and after.channel
# and after.channel.id != before.channel.id
# ):
# try:
# player = lavalink.get_player(member.guild.id)
# if player.is_playing:
# await player.resume(player.current, start=player.position, replace=False)
# log.debug("Bot changed channel - Resume playback")
# except:
# log.debug("Bot changed channel - Unable to resume playback")
channel = self.rgetattr(member, "voice.channel", None) channel = self.rgetattr(member, "voice.channel", None)
bot_voice_state = self.rgetattr(member, "guild.me.voice.self_deaf", None) bot_voice_state = self.rgetattr(member, "guild.me.voice.self_deaf", None)
if ( if (

100
redbot/cogs/audio/core/events/lavalink.py
View File

@ -17,7 +17,6 @@ from ..cog_utils import CompositeMetaClass
log = logging.getLogger("red.cogs.Audio.cog.Events.lavalink") log = logging.getLogger("red.cogs.Audio.cog.Events.lavalink")
ws_audio_log = logging.getLogger("red.Audio.WS.Audio") ws_audio_log = logging.getLogger("red.Audio.WS.Audio")
ws_audio_log.setLevel(logging.WARNING)
_ = Translator("Audio", Path(__file__)) _ = Translator("Audio", Path(__file__))
@ -76,9 +75,7 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
guild=guild, player=player, extra=extra, deafen=deafen, disconnect=disconnect guild=guild, player=player, extra=extra, deafen=deafen, disconnect=disconnect
) )
except Exception: except Exception:
log.exception( log.exception("Error in WEBSOCKET_CLOSED handling for guild: %s", player.guild.id)
f"Error in WEBSOCKET_CLOSED handling for guild: {player.channel.guild.id}"
)
return return
await set_contextual_locales_from_guild(self.bot, guild) await set_contextual_locales_from_guild(self.bot, guild)
@ -95,7 +92,7 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
current_track, self.local_folder_current_path current_track, self.local_folder_current_path
) )
status = await self.config.status() status = await self.config.status()
log.debug(f"Received a new lavalink event for {guild_id}: {event_type}: {extra}") log.debug("Received a new lavalink event for %d: %s: %r", guild_id, event_type, extra)
prev_song: lavalink.Track = player.fetch("prev_song") prev_song: lavalink.Track = player.fetch("prev_song")
await self.maybe_reset_error_counter(player) await self.maybe_reset_error_counter(player)
@ -320,14 +317,17 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
code = 4014 code = 4014
if event_channel_id != channel_id: if event_channel_id != channel_id:
ws_audio_log.info( ws_audio_log.info(
f"Received an op code for a channel that is no longer valid; {event_channel_id} " "Received an op code for a channel that is no longer valid; %d "
f"in guild: {guild_id} - Active channel {channel_id} | " "Reason: Error code %d & %s, %r",
f"Reason: Error code {code} & {reason}." event_channel_id,
code,
reason,
player,
) )
self._ws_op_codes[guild_id]._init(self._ws_op_codes[guild_id]._maxsize) self._ws_op_codes[guild_id]._init(self._ws_op_codes[guild_id]._maxsize)
return return
if player.channel: if player.channel:
current_perms = player.channel.permissions_for(player.channel.guild.me) current_perms = player.channel.permissions_for(player.guild.me)
has_perm = current_perms.speak and current_perms.connect has_perm = current_perms.speak and current_perms.connect
else: else:
has_perm = False has_perm = False
@ -335,8 +335,7 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
player.store("resumes", player.fetch("resumes", 0) + 1) player.store("resumes", player.fetch("resumes", 0) + 1)
await player.resume(player.current, start=player.position, replace=True) await player.resume(player.current, start=player.position, replace=True)
ws_audio_log.info( ws_audio_log.info(
f"Player resumed in channel {channel_id} in guild: {guild_id} | " "Player resumed | Reason: Error code %d & %s, %r", code, reason, player
f"Reason: Error code {code} & {reason}."
) )
self._ws_op_codes[guild_id]._init(self._ws_op_codes[guild_id]._maxsize) self._ws_op_codes[guild_id]._init(self._ws_op_codes[guild_id]._maxsize)
return return
@ -349,12 +348,21 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
delay = player._con_delay.delay() delay = player._con_delay.delay()
ws_audio_log.warning( ws_audio_log.warning(
"YOU CAN IGNORE THIS UNLESS IT'S CONSISTENTLY REPEATING FOR THE SAME GUILD - " "YOU CAN IGNORE THIS UNLESS IT'S CONSISTENTLY REPEATING FOR THE SAME GUILD - "
f"Voice websocket closed for guild {guild_id} -> " "Voice websocket closed for guild %d -> "
f"Socket Closed {voice_ws.socket._closing or voice_ws.socket.closed}. " "Socket Closed %s. "
f"Code: {code} -- Remote: {by_remote} -- {reason}" "Code: %d -- Remote: %s -- %s, %r",
guild_id,
voice_ws.socket._closing or voice_ws.socket.closed,
code,
by_remote,
reason,
player,
) )
ws_audio_log.debug( ws_audio_log.debug(
f"Reconnecting to channel {channel_id} in guild: {guild_id} | {delay:.2f}s" "Reconnecting to channel %d in guild: %d | %.2fs",
channel_id,
guild_id,
delay,
) )
await asyncio.sleep(delay) await asyncio.sleep(delay)
while voice_ws.socket._closing or voice_ws.socket.closed or not voice_ws.open: while voice_ws.socket._closing or voice_ws.socket.closed or not voice_ws.open:
@ -367,8 +375,9 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
await player.resume(player.current, start=player.position, replace=True) await player.resume(player.current, start=player.position, replace=True)
ws_audio_log.info( ws_audio_log.info(
"Voice websocket reconnected " "Voice websocket reconnected "
f"to channel {channel_id} in guild: {guild_id} | " "Reason: Error code %d & Currently playing, %r",
f"Reason: Error code {code} & Currently playing." code,
player,
) )
elif has_perm and player.paused and player.current: elif has_perm and player.paused and player.current:
player.store("resumes", player.fetch("resumes", 0) + 1) player.store("resumes", player.fetch("resumes", 0) + 1)
@ -378,24 +387,27 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
) )
ws_audio_log.info( ws_audio_log.info(
"Voice websocket reconnected " "Voice websocket reconnected "
f"to channel {channel_id} in guild: {guild_id} | " "Reason: Error code %d & Currently Paused, %r",
f"Reason: Error code {code} & Currently Paused." code,
player,
) )
elif has_perm and (not disconnect) and (not player.is_playing): elif has_perm and (not disconnect) and (not player.is_playing):
player.store("resumes", player.fetch("resumes", 0) + 1) player.store("resumes", player.fetch("resumes", 0) + 1)
await player.connect(deafen=deafen) await player.connect(deafen=deafen)
ws_audio_log.info( ws_audio_log.info(
"Voice websocket reconnected " "Voice websocket reconnected "
f"to channel {channel_id} in guild: {guild_id} | " "Reason: Error code %d & Not playing, but auto disconnect disabled, %r",
f"Reason: Error code {code} & Not playing, but auto disconnect disabled." code,
player,
) )
self._ll_guild_updates.discard(guild_id) self._ll_guild_updates.discard(guild_id)
elif not has_perm: elif not has_perm:
self.bot.dispatch("red_audio_audio_disconnect", guild) self.bot.dispatch("red_audio_audio_disconnect", guild)
ws_audio_log.info( ws_audio_log.info(
"Voice websocket disconnected " "Voice websocket disconnected "
f"from channel {channel_id} in guild: {guild_id} | " "Reason: Error code %d & Missing permissions, %r",
f"Reason: Error code {code} & Missing permissions." code,
player,
) )
self._ll_guild_updates.discard(guild_id) self._ll_guild_updates.discard(guild_id)
player.store("autoplay_notified", False) player.store("autoplay_notified", False)
@ -407,9 +419,9 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
else: else:
self.bot.dispatch("red_audio_audio_disconnect", guild) self.bot.dispatch("red_audio_audio_disconnect", guild)
ws_audio_log.info( ws_audio_log.info(
"Voice websocket disconnected " "Voice websocket disconnected Reason: Error code %d & Unknown, %r",
f"from channel {channel_id} in guild: {guild_id} | " code,
f"Reason: Error code {code} & Unknown." player,
) )
self._ll_guild_updates.discard(guild_id) self._ll_guild_updates.discard(guild_id)
player.store("autoplay_notified", False) player.store("autoplay_notified", False)
@ -423,8 +435,7 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
await player.connect(deafen=deafen) await player.connect(deafen=deafen)
await player.resume(player.current, start=player.position, replace=True) await player.resume(player.current, start=player.position, replace=True)
ws_audio_log.info( ws_audio_log.info(
f"Player resumed in channel {channel_id} in guild: {guild_id} | " "Player resumed - Reason: Error code %d & %s, %r", code, reason, player
f"Reason: Error code {code} & {reason}."
) )
elif code in (4015, 4009, 4006, 4000, 1006): elif code in (4015, 4009, 4006, 4000, 1006):
if player._con_delay: if player._con_delay:
@ -433,7 +444,7 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
player._con_delay = ExponentialBackoff(base=1) player._con_delay = ExponentialBackoff(base=1)
delay = player._con_delay.delay() delay = player._con_delay.delay()
ws_audio_log.debug( ws_audio_log.debug(
f"Reconnecting to channel {channel_id} in guild: {guild_id} | {delay:.2f}s" "Reconnecting to channel %d in guild: %d | %.2fs", channel_id, guild_id, delay
) )
await asyncio.sleep(delay) await asyncio.sleep(delay)
if has_perm and player.current and player.is_playing: if has_perm and player.current and player.is_playing:
@ -441,8 +452,9 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
await player.resume(player.current, start=player.position, replace=True) await player.resume(player.current, start=player.position, replace=True)
ws_audio_log.info( ws_audio_log.info(
"Voice websocket reconnected " "Voice websocket reconnected "
f"to channel {channel_id} in guild: {guild_id} | " "Reason: Error code %d & Player is active, %r",
f"Reason: Error code {code} & Player is active." code,
player,
) )
elif has_perm and player.paused and player.current: elif has_perm and player.paused and player.current:
player.store("resumes", player.fetch("resumes", 0) + 1) player.store("resumes", player.fetch("resumes", 0) + 1)
@ -452,24 +464,30 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
) )
ws_audio_log.info( ws_audio_log.info(
"Voice websocket reconnected " "Voice websocket reconnected "
f"to channel {channel_id} in guild: {guild_id} | " "Reason: Error code %d & Player is paused, %r",
f"Reason: Error code {code} & Player is paused." code,
player,
) )
elif has_perm and (not disconnect) and (not player.is_playing): elif has_perm and (not disconnect) and (not player.is_playing):
player.store("resumes", player.fetch("resumes", 0) + 1) player.store("resumes", player.fetch("resumes", 0) + 1)
await player.connect(deafen=deafen) await player.connect(deafen=deafen)
ws_audio_log.info( ws_audio_log.info(
"Voice websocket reconnected " "Voice websocket reconnected "
f"to channel {channel_id} in guild: {guild_id} | " "to channel %d in guild: %d | "
f"Reason: Error code {code} & Not playing." "Reason: Error code %d & Not playing, %r",
channel_id,
guild_id,
code,
player,
) )
self._ll_guild_updates.discard(guild_id) self._ll_guild_updates.discard(guild_id)
elif not has_perm: elif not has_perm:
self.bot.dispatch("red_audio_audio_disconnect", guild) self.bot.dispatch("red_audio_audio_disconnect", guild)
ws_audio_log.info( ws_audio_log.info(
"Voice websocket disconnected " "Voice websocket disconnected "
f"from channel {channel_id} in guild: {guild_id} | " "Reason: Error code %d & Missing permissions, %r",
f"Reason: Error code {code} & Missing permissions." code,
player,
) )
self._ll_guild_updates.discard(guild_id) self._ll_guild_updates.discard(guild_id)
player.store("autoplay_notified", False) player.store("autoplay_notified", False)
@ -484,8 +502,12 @@ class LavalinkEvents(MixinMeta, metaclass=CompositeMetaClass):
await player.resume(player.current, start=player.position, replace=False) await player.resume(player.current, start=player.position, replace=False)
ws_audio_log.info( ws_audio_log.info(
"WS EVENT - IGNORED (Healthy Socket) | " "WS EVENT - IGNORED (Healthy Socket) | "
f"Voice websocket closed event for guild {guild_id} -> " "Voice websocket closed event "
f"Code: {code} -- Remote: {by_remote} -- {reason}" "Code: %d -- Remote: %s -- %s, %r",
code,
by_remote,
reason,
player,
) )
except Exception: except Exception:
log.exception("Error in task") log.exception("Error in task")

14
redbot/cogs/audio/core/tasks/player.py
View File

@ -24,7 +24,7 @@ class PlayerTasks(MixinMeta, metaclass=CompositeMetaClass):
pause_times: Dict = {} pause_times: Dict = {}
while True: while True:
async for p in AsyncIter(lavalink.all_players()): async for p in AsyncIter(lavalink.all_players()):
server = p.channel.guild server = p.guild
if await self.bot.cog_disabled_in_guild(self, server): if await self.bot.cog_disabled_in_guild(self, server):
continue continue
@ -37,11 +37,7 @@ class PlayerTasks(MixinMeta, metaclass=CompositeMetaClass):
try: try:
await p.pause(False) await p.pause(False)
except Exception as err: except Exception as err:
debug_exc_log( debug_exc_log(log, err, "Exception raised in Audio's unpausing %r.", p)
log,
err,
f"Exception raised in Audio's unpausing player for {server.id}.",
)
pause_times.pop(server.id, None) pause_times.pop(server.id, None)
servers = stop_times.copy() servers = stop_times.copy()
servers.update(pause_times) servers.update(pause_times)
@ -61,7 +57,7 @@ class PlayerTasks(MixinMeta, metaclass=CompositeMetaClass):
).currently_auto_playing_in.set([]) ).currently_auto_playing_in.set([])
except Exception as err: except Exception as err:
debug_exc_log( debug_exc_log(
log, err, f"Exception raised in Audio's emptydc_timer for {sid}." log, err, "Exception raised in Audio's emptydc_timer for %s.", sid
) )
elif sid in stop_times and await self.config.guild(server_obj).emptydc_enabled(): elif sid in stop_times and await self.config.guild(server_obj).emptydc_enabled():
@ -81,7 +77,7 @@ class PlayerTasks(MixinMeta, metaclass=CompositeMetaClass):
if "No such player for that guild" in str(err): if "No such player for that guild" in str(err):
stop_times.pop(sid, None) stop_times.pop(sid, None)
debug_exc_log( debug_exc_log(
log, err, f"Exception raised in Audio's emptydc_timer for {sid}." log, err, "Exception raised in Audio's emptydc_timer for %s.", sid
) )
elif ( elif (
sid in pause_times and await self.config.guild(server_obj).emptypause_enabled() sid in pause_times and await self.config.guild(server_obj).emptypause_enabled()
@ -94,6 +90,6 @@ class PlayerTasks(MixinMeta, metaclass=CompositeMetaClass):
if "No such player for that guild" in str(err): if "No such player for that guild" in str(err):
pause_times.pop(sid, None) pause_times.pop(sid, None)
debug_exc_log( debug_exc_log(
log, err, f"Exception raised in Audio's pausing for {sid}." log, err, "Exception raised in Audio's pausing for %s.", sid
) )
await asyncio.sleep(5) await asyncio.sleep(5)

11
redbot/cogs/audio/core/tasks/startup.py
View File

@ -31,6 +31,7 @@ class StartUpTasks(MixinMeta, metaclass=CompositeMetaClass):
# There has to be a task since this requires the bot to be ready # There has to be a task since this requires the bot to be ready
# If it waits for ready in startup, we cause a deadlock during initial load # If it waits for ready in startup, we cause a deadlock during initial load
# as initial load happens before the bot can ever be ready. # as initial load happens before the bot can ever be ready.
lavalink.set_logging_level(self.bot._cli_flags.logging_level)
self.cog_init_task = self.bot.loop.create_task(self.initialize()) self.cog_init_task = self.bot.loop.create_task(self.initialize())
self.cog_init_task.add_done_callback(task_callback) self.cog_init_task.add_done_callback(task_callback)
@ -139,7 +140,9 @@ class StartUpTasks(MixinMeta, metaclass=CompositeMetaClass):
tries += 1 tries += 1
except Exception as exc: except Exception as exc:
tries += 1 tries += 1
debug_exc_log(log, exc, "Failed to restore music voice channel") debug_exc_log(
log, exc, "Failed to restore music voice channel %s", vc_id
)
if vc is None: if vc is None:
break break
else: else:
@ -160,8 +163,9 @@ class StartUpTasks(MixinMeta, metaclass=CompositeMetaClass):
player.maybe_shuffle() player.maybe_shuffle()
if not player.is_playing: if not player.is_playing:
await player.play() await player.play()
log.info("Restored %r", player)
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Error restoring player in {guild_id}") debug_exc_log(log, err, "Error restoring player in %d", guild_id)
await self.api_interface.persistent_queue_api.drop(guild_id) await self.api_interface.persistent_queue_api.drop(guild_id)
for guild_id, (notify_channel_id, vc_id) in metadata.items(): for guild_id, (notify_channel_id, vc_id) in metadata.items():
@ -208,7 +212,7 @@ class StartUpTasks(MixinMeta, metaclass=CompositeMetaClass):
tries += 1 tries += 1
except Exception as exc: except Exception as exc:
tries += 1 tries += 1
debug_exc_log(log, exc, "Failed to restore music voice channel") debug_exc_log(log, exc, "Failed to restore music voice channel %s", vc_id)
if vc is None: if vc is None:
break break
else: else:
@ -222,6 +226,7 @@ class StartUpTasks(MixinMeta, metaclass=CompositeMetaClass):
if player.volume != volume: if player.volume != volume:
await player.set_volume(volume) await player.set_volume(volume)
player.maybe_shuffle() player.maybe_shuffle()
log.info("Restored %r", player)
if not player.is_playing: if not player.is_playing:
notify_channel = player.fetch("channel") notify_channel = player.fetch("channel")
try: try:

8
redbot/cogs/audio/core/utilities/formatting.py
View File

@ -167,7 +167,7 @@ class FormattingUtilities(MixinMeta, metaclass=CompositeMetaClass):
query_obj=query, query_obj=query,
): ):
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Query is not allowed in {ctx.guild} ({ctx.guild.id})") log.debug("Query is not allowed in %r (%d)", ctx.guild.name, ctx.guild.id)
self.update_player_lock(ctx, False) self.update_player_lock(ctx, False)
return await self.send_embed_msg( return await self.send_embed_msg(
ctx, title=_("This track is not allowed in this server.") ctx, title=_("This track is not allowed in this server.")
@ -185,7 +185,7 @@ class FormattingUtilities(MixinMeta, metaclass=CompositeMetaClass):
player.add(ctx.author, search_choice) player.add(ctx.author, search_choice)
player.maybe_shuffle() player.maybe_shuffle()
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", player.channel.guild, search_choice, ctx.author "red_audio_track_enqueue", player.guild, search_choice, ctx.author
) )
else: else:
return await self.send_embed_msg(ctx, title=_("Track exceeds maximum length.")) return await self.send_embed_msg(ctx, title=_("Track exceeds maximum length."))
@ -199,9 +199,7 @@ class FormattingUtilities(MixinMeta, metaclass=CompositeMetaClass):
) )
player.add(ctx.author, search_choice) player.add(ctx.author, search_choice)
player.maybe_shuffle() player.maybe_shuffle()
self.bot.dispatch( self.bot.dispatch("red_audio_track_enqueue", player.guild, search_choice, ctx.author)
"red_audio_track_enqueue", player.channel.guild, search_choice, ctx.author
)
if not guild_data["shuffle"] and queue_dur > 0: if not guild_data["shuffle"] and queue_dur > 0:
songembed.set_footer( songembed.set_footer(

22
redbot/cogs/audio/core/utilities/player.py
View File

@ -120,7 +120,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
async def is_requester(self, ctx: commands.Context, member: discord.Member) -> bool: async def is_requester(self, ctx: commands.Context, member: discord.Member) -> bool:
try: try:
player = lavalink.get_player(ctx.guild.id) player = lavalink.get_player(ctx.guild.id)
log.debug(f"Current requester is {player.current.requester}") log.debug("Current requester is %s", player.current.requester)
return player.current.requester.id == member.id return player.current.requester.id == member.id
except Exception as err: except Exception as err:
debug_exc_log(log, err, "Caught error in `is_requester`") debug_exc_log(log, err, "Caught error in `is_requester`")
@ -128,7 +128,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
async def _skip_action(self, ctx: commands.Context, skip_to_track: int = None) -> None: async def _skip_action(self, ctx: commands.Context, skip_to_track: int = None) -> None:
player = lavalink.get_player(ctx.guild.id) player = lavalink.get_player(ctx.guild.id)
autoplay = await self.config.guild(player.channel.guild).auto_play() autoplay = await self.config.guild(player.guild).auto_play()
if not player.current or (not player.queue and not autoplay): if not player.current or (not player.queue and not autoplay):
try: try:
pos, dur = player.position, player.current.length pos, dur = player.position, player.current.length
@ -193,7 +193,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
), ),
) )
await self.send_embed_msg(ctx, embed=embed) await self.send_embed_msg(ctx, embed=embed)
self.bot.dispatch("red_audio_skip_track", player.channel.guild, player.current, ctx.author) self.bot.dispatch("red_audio_skip_track", player.guild, player.current, ctx.author)
await player.play() await player.play()
player.queue += queue_to_append player.queue += queue_to_append
@ -218,7 +218,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
return return
if not await self.config.guild_from_id(guild_id).auto_deafen(): if not await self.config.guild_from_id(guild_id).auto_deafen():
return return
await player.channel.guild.change_voice_state(channel=player.channel, self_deaf=True) await player.guild.change_voice_state(channel=player.channel, self_deaf=True)
async def _get_spotify_tracks( async def _get_spotify_tracks(
self, ctx: commands.Context, query: Query, forced: bool = False self, ctx: commands.Context, query: Query, forced: bool = False
@ -452,7 +452,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
query_obj=query, query_obj=query,
): ):
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Query is not allowed in {ctx.guild} ({ctx.guild.id})") log.debug("Query is not allowed in %r (%d)", ctx.guild.name, ctx.guild.id)
continue continue
elif guild_data["maxlength"] > 0: elif guild_data["maxlength"] > 0:
if self.is_track_length_allowed(track, guild_data["maxlength"]): if self.is_track_length_allowed(track, guild_data["maxlength"]):
@ -466,7 +466,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
) )
player.add(ctx.author, track) player.add(ctx.author, track)
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", player.channel.guild, track, ctx.author "red_audio_track_enqueue", player.guild, track, ctx.author
) )
else: else:
@ -479,9 +479,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
} }
) )
player.add(ctx.author, track) player.add(ctx.author, track)
self.bot.dispatch( self.bot.dispatch("red_audio_track_enqueue", player.guild, track, ctx.author)
"red_audio_track_enqueue", player.channel.guild, track, ctx.author
)
player.maybe_shuffle(0 if empty_queue else 1) player.maybe_shuffle(0 if empty_queue else 1)
if len(tracks) > track_len: if len(tracks) > track_len:
@ -544,7 +542,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
query_obj=query, query_obj=query,
): ):
if IS_DEBUG: if IS_DEBUG:
log.debug(f"Query is not allowed in {ctx.guild} ({ctx.guild.id})") log.debug("Query is not allowed in %r (%d)", ctx.guild.name, ctx.guild.id)
self.update_player_lock(ctx, False) self.update_player_lock(ctx, False)
return await self.send_embed_msg( return await self.send_embed_msg(
ctx, title=_("This track is not allowed in this server.") ctx, title=_("This track is not allowed in this server.")
@ -562,7 +560,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
player.maybe_shuffle() player.maybe_shuffle()
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", "red_audio_track_enqueue",
player.channel.guild, player.guild,
single_track, single_track,
ctx.author, ctx.author,
) )
@ -583,7 +581,7 @@ class PlayerUtilities(MixinMeta, metaclass=CompositeMetaClass):
player.add(ctx.author, single_track) player.add(ctx.author, single_track)
player.maybe_shuffle() player.maybe_shuffle()
self.bot.dispatch( self.bot.dispatch(
"red_audio_track_enqueue", player.channel.guild, single_track, ctx.author "red_audio_track_enqueue", player.guild, single_track, ctx.author
) )
except IndexError: except IndexError:
self.update_player_lock(ctx, False) self.update_player_lock(ctx, False)

4
redbot/cogs/audio/core/utilities/playlists.py
View File

@ -428,14 +428,14 @@ class PlaylistUtilities(MixinMeta, metaclass=CompositeMetaClass):
track = result.tracks[0] track = result.tracks[0]
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Failed to get track for {song_url}") debug_exc_log(log, err, "Failed to get track for %r", song_url)
continue continue
try: try:
track_obj = self.get_track_json(player, other_track=track) track_obj = self.get_track_json(player, other_track=track)
track_list.append(track_obj) track_list.append(track_obj)
successful_count += 1 successful_count += 1
except Exception as err: except Exception as err:
debug_exc_log(log, err, f"Failed to create track for {track}") debug_exc_log(log, err, "Failed to create track for %r", track)
continue continue
if (track_count % 2 == 0) or (track_count == len(uploaded_track_list)): if (track_count % 2 == 0) or (track_count == len(uploaded_track_list)):
await notifier.notify_user( await notifier.notify_user(

2
redbot/cogs/audio/manager.py
View File

@ -287,7 +287,7 @@ class ServerManager:
# hasn't been published yet # hasn't been published yet
raise LavalinkDownloadFailed( raise LavalinkDownloadFailed(
f"Lavalink jar version {JAR_VERSION}_{JAR_BUILD} hasn't been published " f"Lavalink jar version {JAR_VERSION}_{JAR_BUILD} hasn't been published "
f"yet", "yet",
response=response, response=response,
should_retry=False, should_retry=False,
) )

2
redbot/cogs/audio/utils.py
View File

@ -219,7 +219,7 @@ class PlaylistScope(Enum):
def task_callback(task: asyncio.Task) -> None: def task_callback(task: asyncio.Task) -> None:
with contextlib.suppress(asyncio.CancelledError, asyncio.InvalidStateError): with contextlib.suppress(asyncio.CancelledError, asyncio.InvalidStateError):
if exc := task.exception(): if exc := task.exception():
log.exception(f"{task.get_name()} raised an Exception", exc_info=exc) log.exception("%s raised an Exception", task.get_name(), exc_info=exc)
def has_internal_server(): def has_internal_server():

2
setup.cfg
View File

@ -61,7 +61,7 @@ install_requires =
python-Levenshtein-wheels==0.13.2 python-Levenshtein-wheels==0.13.2
pytz==2021.1 pytz==2021.1
PyYAML==5.4.1 PyYAML==5.4.1
Red-Lavalink==0.8.0 Red-Lavalink==0.8.1
rich==9.9.0 rich==9.9.0
schema==0.7.4 schema==0.7.4
six==1.15.0 six==1.15.0