Update core/plot.py

core/plot.py

@@ -1,22 +1,22 @@
 import plotly.graph_objects as go
 import plotly.express as px
 import pandas as pd
-import logging
-
-logging.basicConfig(level=logging.DEBUG, filename="/tmp/debug.log", filemode="a")
-
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import pandas as pd
 import numpy as np
 import logging
 import matplotlib.pyplot as plt
+import base64
+from datetime import timedelta
 from torchviz import make_dot
+import torch
 
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.DEBUG, filename="/tmp/debug.log", filemode="a", format='%(asctime)s - %(levelname)s - %(message)s')
 
 def plot_indicators(df, ticker):
     try:
+        logging.info(f"Starting plot_indicators for {ticker}")
+        logging.debug(f"DataFrame columns: {df.columns.tolist()}")
+        logging.debug(f"Sample data: {df.head().to_dict()}")
+
         fig = make_subplots(
             rows=7, cols=1, shared_xaxes=True, vertical_spacing=0.03,
             subplot_titles=(
@@ -27,23 +27,33 @@ def plot_indicators(df, ticker):
         )
 
         # Price and Moving Averages
-        fig.add_trace(
-            go.Candlestick(
-                x=df['Date'], open=df['Open'], high=df['High'], low=df['Low'], close=df['value'],
-                name='Price', increasing_line_color='#00CC96', decreasing_line_color='#EF553B'
-            ), row=1, col=1
-        )
+        if all(col in df for col in ['Date', 'Open', 'High', 'Low', 'value']):
+            logging.debug("Adding candlestick trace")
+            fig.add_trace(
+                go.Candlestick(
+                    x=df['Date'], open=df['Open'], high=df['High'], low=df['Low'], close=df['value'],
+                    name='Price', increasing_line_color='#00CC96', decreasing_line_color='#EF553B'
+                ), row=1, col=1
+            )
+        else:
+            logging.warning("Missing columns for candlestick: 'Date', 'Open', 'High', 'Low', 'value'")
+
         for ma in ['sma_10', 'sma_20', 'sma_50', 'ema_12', 'ema_26', 'ema_50']:
             if ma in df:
+                logging.debug(f"Adding {ma} trace")
                 fig.add_trace(
                     go.Scatter(x=df['Date'], y=df[ma], name=ma.upper(), line=dict(width=1.5)),
                     row=1, col=1
                 )
-        # Handle both key variants: generated with '2.0' vs '2'
+            else:
+                logging.warning(f"{ma} not found in DataFrame")
+
+        # Bollinger Bands
         bb_u = 'bbu_20_2.0' if 'bbu_20_2.0' in df else ('bbu_20_2' if 'bbu_20_2' in df else None)
         bb_m = 'bbm_20_2.0' if 'bbm_20_2.0' in df else ('bbm_20_2' if 'bbm_20_2' in df else None)
         bb_l = 'bbl_20_2.0' if 'bbl_20_2.0' in df else ('bbl_20_2' if 'bbl_20_2' in df else None)
         if bb_u and bb_m and bb_l:
+            logging.debug("Adding Bollinger Bands traces")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df[bb_u], name='BB Upper', line=dict(color='gray', dash='dot')),
                 row=1, col=1
@@ -56,9 +66,12 @@ def plot_indicators(df, ticker):
                 go.Scatter(x=df['Date'], y=df[bb_l], name='BB Lower', line=dict(color='gray', dash='dot')),
                 row=1, col=1
             )
+        else:
+            logging.warning(f"Bollinger Bands columns missing: {bb_u}, {bb_m}, {bb_l}")
 
-        # Enhanced Signal Plotting
-        if 'Signal' in df.columns:
+        # Signals
+        if 'Signal' in df:
+            logging.debug("Adding signal traces")
             buy_signals = df[df['Signal'] == 'Buy']
             sell_signals = df[df['Signal'] == 'Sell']
             hold_signals = df[df['Signal'] == 'Hold']
@@ -83,26 +96,36 @@ def plot_indicators(df, ticker):
                     opacity=0.5
                 ), row=1, col=1
             )
+        else:
+            logging.warning("Signal column not found in DataFrame")
 
         # Position Size and Risk Annotation
         if 'atr_14' in df:
             atr = df['atr_14'].iloc[-1]
             stop_distance = atr * 2
-            position_size = (10000 * 0.01) / stop_distance
+            position_size = (10000 * 0.01) / stop_distance if stop_distance != 0 else 0
+            logging.debug(f"ATR: {atr}, Position Size: {position_size}")
             fig.add_annotation(
                 text=f"Position Size: {position_size:.0f} shares (1% risk, ATR {atr:.2f})",
                 xref="paper", yref="paper", x=0.05, y=0.95, showarrow=False,
                 font=dict(color="black", size=12)
             )
+        else:
+            logging.warning("atr_14 not found for position size annotation")
 
         # Volume
-        fig.add_trace(
-            go.Bar(x=df['Date'], y=df['Volume'], name='Volume', marker_color='blue', opacity=0.5),
-            row=2, col=1
-        )
+        if 'Volume' in df:
+            logging.debug("Adding volume trace")
+            fig.add_trace(
+                go.Bar(x=df['Date'], y=df['Volume'], name='Volume', marker_color='blue', opacity=0.5),
+                row=2, col=1
+            )
+        else:
+            logging.warning("Volume column not found in DataFrame")
 
         # MACD & RSI
-        if 'macd_12_26_9' in df:
+        if 'macd_12_26_9' in df and 'macds_12_26_9' in df and 'macdh_12_26_9' in df:
+            logging.debug("Adding MACD traces")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df['macd_12_26_9'], name='MACD', line=dict(color='blue')),
                 row=3, col=1
@@ -115,28 +138,35 @@ def plot_indicators(df, ticker):
                 go.Bar(x=df['Date'], y=df['macdh_12_26_9'], name='MACD Hist', marker_color='gray'),
                 row=3, col=1
             )
+        else:
+            logging.warning("MACD columns (macd_12_26_9, macds_12_26_9, macdh_12_26_9) not found")
+
         if 'rsi_14' in df:
+            logging.debug("Adding RSI 14 trace")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df['rsi_14'], name='RSI 14', line=dict(color='purple')),
                 row=3, col=1
             )
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[70, 70],
-                                      showlegend=False, line=dict(color='red', dash='dash', width=1)), row=3, col=1)
+                                    showlegend=False, line=dict(color='red', dash='dash', width=1)), row=3, col=1)
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[30, 30],
-                                      showlegend=False, line=dict(color='green', dash='dash', width=1)), row=3, col=1)
-        if 'rsi_21' in df:
-            fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['rsi_21'], name='RSI 21', line=dict(color='magenta', dash='dash')),
-                row=3, col=1
-            )
-        if 'rsi_50' in df:
-            fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['rsi_50'], name='RSI 50', line=dict(color='cyan', dash='dot')),
-                row=3, col=1
-            )
+                                    showlegend=False, line=dict(color='green', dash='dash', width=1)), row=3, col=1)
+        else:
+            logging.warning("rsi_14 not found in DataFrame")
+
+        for rsi in ['rsi_21', 'rsi_50']:
+            if rsi in df:
+                logging.debug(f"Adding {rsi} trace")
+                fig.add_trace(
+                    go.Scatter(x=df['Date'], y=df[rsi], name=rsi.upper(), line=dict(color='magenta' if rsi == 'rsi_21' else 'cyan', dash='dash' if rsi == 'rsi_21' else 'dot')),
+                    row=3, col=1
+                )
+            else:
+                logging.warning(f"{rsi} not found in DataFrame")
 
         # Stochastic & Williams %R
-        if 'stochk_14_3_3' in df:
+        if 'stochk_14_3_3' in df and 'stochd_14_3_3' in df:
+            logging.debug("Adding Stochastic traces")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df['stochk_14_3_3'], name='Stoch %K', line=dict(color='blue')),
                 row=4, col=1
@@ -146,54 +176,71 @@ def plot_indicators(df, ticker):
                 row=4, col=1
             )
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[80, 80],
-                                      showlegend=False, line=dict(color='red', dash='dash', width=1)), row=4, col=1)
+                                    showlegend=False, line=dict(color='red', dash='dash', width=1)), row=4, col=1)
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[20, 20],
-                                      showlegend=False, line=dict(color='green', dash='dash', width=1)), row=4, col=1)
+                                    showlegend=False, line=dict(color='green', dash='dash', width=1)), row=4, col=1)
+        else:
+            logging.warning("Stochastic columns (stochk_14_3_3, stochd_14_3_3) not found")
+
         if 'willr_14' in df:
+            logging.debug("Adding Williams %R trace")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df['willr_14'], name='Williams %R', line=dict(color='green')),
                 row=4, col=1
             )
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[-20, -20],
-                                      showlegend=False, line=dict(color='red', dash='dash', width=1)), row=4, col=1)
+                                    showlegend=False, line=dict(color='red', dash='dash', width=1)), row=4, col=1)
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[-80, -80],
-                                      showlegend=False, line=dict(color='green', dash='dash', width=1)), row=4, col=1)
+                                    showlegend=False, line=dict(color='green', dash='dash', width=1)), row=4, col=1)
+        else:
+            logging.warning("willr_14 not found in DataFrame")
 
         # ADX & DI
-        if 'adx_14' in df:
+        if all(col in df for col in ['adx_14', 'pdi_14', 'mdi_14']):
+            logging.debug("Adding ADX and DI traces")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df['adx_14'], name='ADX', line=dict(color='blue')),
                 row=5, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df.get('pdi_14'), name='+DI', line=dict(color='green')),
+                go.Scatter(x=df['Date'], y=df['pdi_14'], name='+DI', line=dict(color='green')),
                 row=5, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df.get('mdi_14'), name='-DI', line=dict(color='red')),
+                go.Scatter(x=df['Date'], y=df['mdi_14'], name='-DI', line=dict(color='red')),
                 row=5, col=1
             )
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[25, 25],
-                                      showlegend=False, line=dict(color='black', dash='dash', width=1)), row=5, col=1)
+                                    showlegend=False, line=dict(color='black', dash='dash', width=1)), row=5, col=1)
+        else:
+            logging.warning("ADX/DI columns (adx_14, pdi_14, mdi_14) not found")
 
         # ATR & CCI
         if 'atr_14' in df:
+            logging.debug("Adding ATR trace")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df['atr_14'], name='ATR', line=dict(color='orange')),
                 row=6, col=1
             )
+        else:
+            logging.warning("atr_14 not found in DataFrame")
+
         if 'cci_20' in df:
+            logging.debug("Adding CCI trace")
             fig.add_trace(
                 go.Scatter(x=df['Date'], y=df['cci_20'], name='CCI', line=dict(color='purple')),
                 row=6, col=1
             )
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[100, 100],
-                                      showlegend=False, line=dict(color='red', dash='dash', width=1)), row=6, col=1)
+                                    showlegend=False, line=dict(color='red', dash='dash', width=1)), row=6, col=1)
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[-100, -100],
-                                      showlegend=False, line=dict(color='green', dash='dash', width=1)), row=6, col=1)
+                                    showlegend=False, line=dict(color='green', dash='dash', width=1)), row=6, col=1)
+        else:
+            logging.warning("cci_20 not found in DataFrame")
 
-        # Signal Strength Plot
+        # Signal Strength
         if all(col in df for col in ['RSI_Signal', 'MACD_Signal', 'ADX_Signal', 'Sentiment_Signal', 'Model_Signal']):
+            logging.debug("Adding signal strength trace")
             signal_strength = (
                 df['RSI_Signal'].abs() +
                 df['MACD_Signal'].abs() +
@@ -208,7 +255,9 @@ def plot_indicators(df, ticker):
                 ), row=7, col=1
             )
             fig.add_trace(go.Scatter(x=[df['Date'].min(), df['Date'].max()], y=[3, 3],
-                                      showlegend=False, line=dict(color='orange', dash='dash', width=1)), row=7, col=1)
+                                    showlegend=False, line=dict(color='orange', dash='dash', width=1)), row=7, col=1)
+        else:
+            logging.warning("Signal strength columns (RSI_Signal, MACD_Signal, ADX_Signal, Sentiment_Signal, Model_Signal) not found")
 
         fig.update_layout(
             title=f"{ticker} Price and Technical Indicators",
@@ -223,21 +272,33 @@ def plot_indicators(df, ticker):
             paper_bgcolor="white",
             hovermode="x unified"
         )
+        logging.info(f"Indicators plot generated for {ticker}")
         return fig
     except Exception as e:
-        logging.error(f"Plot indicators error: {e}")
+        logging.error(f"Plot indicators error: {str(e)}")
         return None
+
 def plot_future_forecast(df, result, timeframe):
     try:
+        logging.debug(f"Starting plot_future_forecast for timeframe: {timeframe}")
         fig = go.Figure()
-        fig.add_trace(go.Scatter(x=df['Date'], y=df['value'], name='Historical Close', line=dict(color='blue')))
+        if 'Date' in df and 'value' in df:
+            logging.debug("Adding historical close trace")
+            fig.add_trace(go.Scatter(x=df['Date'], y=df['value'], name='Historical Close', line=dict(color='blue')))
+        else:
+            logging.warning("Missing 'Date' or 'value' columns for historical close")
+
         if "latest_prediction" in result:
             last_date = df['Date'].iloc[-1]
             horizon = len(result["latest_prediction"]) if hasattr(result["latest_prediction"], '__len__') else 1
             freq_map = {'1m': 'T', '2m': '2T', '5m': '5T', '15m': '15T', '30m': '30T', '60m': 'H', '90m': '90T', '1h': 'H', '1d': 'D', '5d': '5D', '1wk': 'W', '1mo': 'M', '3mo': '3M'}
             future_dates = pd.date_range(start=last_date + pd.Timedelta(days=1), periods=horizon, freq=freq_map.get(timeframe, 'D'))
             pred_values = result["latest_prediction"].tolist() if hasattr(result["latest_prediction"], 'tolist') else list(result["latest_prediction"]) if hasattr(result["latest_prediction"], '__iter__') else [result["latest_prediction"]]
+            logging.debug(f"Adding forecast trace with {horizon} points")
             fig.add_trace(go.Scatter(x=future_dates, y=pred_values, name='Forecast Close', line=dict(color='orange', dash='dash')))
+        else:
+            logging.warning("latest_prediction not found in result")
+
         fig.update_layout(
             title="Historical Data and Future Forecast",
             template="plotly_white",
@@ -245,19 +306,22 @@ def plot_future_forecast(df, result, timeframe):
             xaxis_title="Date",
             yaxis_title="Value"
         )
+        logging.info("Future forecast plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot future forecast error: {e}")
+        logging.error(f"Plot future forecast error: {str(e)}")
         return None
-    
-# Other plotting functions remain unchanged
+
 def plot_forecast(result, df):
     try:
+        logging.debug("Starting plot_forecast")
         actual = result.get("actual", [])
         forecast = result.get("forecast", [])
         if not actual or not forecast:
+            logging.warning("Actual or forecast data missing")
             return None
         dates = df['Date'].iloc[-len(actual):]
+        logging.debug(f"Adding actual and forecast traces with {len(actual)} points")
         fig = go.Figure()
         fig.add_trace(go.Scatter(x=dates, y=actual, name='Actual', line=dict(color='blue')))
         fig.add_trace(go.Scatter(x=dates, y=forecast, name='Forecast', line=dict(color='orange')))
@@ -272,18 +336,20 @@ def plot_forecast(result, df):
             plot_bgcolor="white",
             paper_bgcolor="white"
         )
+        logging.info("Forecast plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot forecast error: {e}")
+        logging.error(f"Plot forecast error: {str(e)}")
         return None
 
-# ... (other plotting functions like plot_future_forecast, plot_metrics_r2, etc., remain as provided)
-
 def plot_metrics_r2(result):
     try:
+        logging.debug("Starting plot_metrics_r2")
         metrics = result.get("metrics", {})
         if not metrics:
+            logging.warning("Metrics data missing")
             return None
+        logging.debug(f"Metrics available: {metrics.keys()}")
         fig = go.Figure()
         fig.add_trace(go.Bar(
             x=['R²', 'MAPE'],
@@ -301,16 +367,20 @@ def plot_metrics_r2(result):
             plot_bgcolor="white",
             paper_bgcolor="white"
         )
+        logging.info("R² and MAPE metrics plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot R2 error: {e}")
+        logging.error(f"Plot R2 error: {str(e)}")
         return None
 
 def plot_metrics_errors(result):
     try:
+        logging.debug("Starting plot_metrics_errors")
         metrics = result.get("metrics", {})
         if not metrics:
+            logging.warning("Metrics data missing")
             return None
+        logging.debug(f"Metrics available: {metrics.keys()}")
         fig = go.Figure()
         fig.add_trace(go.Bar(
             x=['RMSE', 'MAE'],
@@ -328,16 +398,20 @@ def plot_metrics_errors(result):
             plot_bgcolor="white",
             paper_bgcolor="white"
         )
+        logging.info("Error metrics plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot metrics errors: {e}")
+        logging.error(f"Plot metrics errors: {str(e)}")
         return None
 
 def plot_metrics_precision_recall(result):
     try:
+        logging.debug("Starting plot_metrics_precision_recall")
         metrics = result.get("metrics", {})
         if not metrics:
+            logging.warning("Metrics data missing")
             return None
+        logging.debug(f"Metrics available: {metrics.keys()}")
         fig = go.Figure()
         fig.add_trace(go.Bar(
             x=['Precision', 'Recall'],
@@ -355,16 +429,20 @@ def plot_metrics_precision_recall(result):
             plot_bgcolor="white",
             paper_bgcolor="white"
         )
+        logging.info("Precision and recall metrics plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot precision recall error: {e}")
+        logging.error(f"Plot precision recall error: {str(e)}")
         return None
 
 def plot_metrics_risk(result):
     try:
+        logging.debug("Starting plot_metrics_risk")
         metrics = result.get("metrics", {})
         if not metrics:
+            logging.warning("Metrics data missing")
             return None
+        logging.debug(f"Metrics available: {metrics.keys()}")
         fig = go.Figure()
         fig.add_trace(go.Bar(
             x=['MASE', 'Sharpe', 'Volatility'],
@@ -382,17 +460,21 @@ def plot_metrics_risk(result):
             plot_bgcolor="white",
             paper_bgcolor="white"
         )
+        logging.info("Risk metrics plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot risk metrics error: {e}")
+        logging.error(f"Plot risk metrics error: {str(e)}")
         return None
 
 def plot_loss_curve(result):
     try:
+        logging.debug("Starting plot_loss_curve")
         train_loss = result.get("train_loss", [])
         val_loss = result.get("val_loss", [])
         if not train_loss:
+            logging.warning("Train loss data missing")
             return None
+        logging.debug(f"Train loss length: {len(train_loss)}, Val loss length: {len(val_loss)}")
         epochs = list(range(1, len(train_loss) + 1))
         fig = go.Figure()
         fig.add_trace(go.Scatter(x=epochs, y=train_loss, mode='lines', name='Train Loss', line=dict(color='#00CC96')))
@@ -408,21 +490,25 @@ def plot_loss_curve(result):
             plot_bgcolor="white",
             paper_bgcolor="white"
         )
+        logging.info("Loss curve plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot loss curve error: {e}")
+        logging.error(f"Plot loss curve error: {str(e)}")
         return None
 
-
 def plot_model_architecture(result):
     try:
+        logging.debug("Starting plot_model_architecture")
         model = result.get('model')
         if not model:
+            logging.warning("Model not found in result")
             return None
+        logging.debug(f"Model architecture: {result.get('arch', {})}")
         dummy_input = torch.randn(1, result['arch']['window'], result['arch']['input_dim'])
         graph = make_dot(model(dummy_input), params=dict(model.named_parameters()))
         graph.format = 'png'
         graph.render("model_arch", cleanup=True)
+        logging.debug("Model architecture graph rendered")
         fig = go.Figure()
         fig.add_layout_image(
             dict(
@@ -438,21 +524,35 @@ def plot_model_architecture(result):
             template="plotly_dark",
             showlegend=False
         )
+        logging.info("Model architecture plot generated")
         return fig
     except Exception as e:
-        logging.error(f"Plot model architecture error: {e}")
+        logging.error(f"Plot model architecture error: {str(e)}")
         return None
 
 def plot_signals(signals_df, ticker):
     try:
-        logging.debug(f"Plotting signals for {ticker}")
+        logging.debug(f"Starting plot_signals for {ticker}")
+        logging.debug(f"Signals DataFrame columns: {signals_df.columns.tolist()}")
         fig = go.Figure()
         x_col = 'Date' if 'Date' in signals_df.columns else signals_df.index
-        fig.add_trace(go.Scatter(x=signals_df[x_col], y=signals_df['Price'], mode='lines', name='Price', line=dict(color='blue')))
+        if 'Price' in signals_df:
+            logging.debug("Adding price trace")
+            fig.add_trace(go.Scatter(x=signals_df[x_col], y=signals_df['Price'], mode='lines', name='Price', line=dict(color='blue')))
+        else:
+            logging.warning("Price column not found in signals_df")
         buy_signals = signals_df[signals_df['Signal'] == 'Buy']
         sell_signals = signals_df[signals_df['Signal'] == 'Sell']
-        fig.add_trace(go.Scatter(x=buy_signals[x_col], y=buy_signals['Price'], mode='markers', name='Buy', marker=dict(symbol='triangle-up', size=10, color='green')))
-        fig.add_trace(go.Scatter(x=sell_signals[x_col], y=sell_signals['Price'], mode='markers', name='Sell', marker=dict(symbol='triangle-down', size=10, color='red')))
+        if not buy_signals.empty:
+            logging.debug(f"Adding {len(buy_signals)} buy signal markers")
+            fig.add_trace(go.Scatter(x=buy_signals[x_col], y=buy_signals['Price'], mode='markers', name='Buy', marker=dict(symbol='triangle-up', size=10, color='green')))
+        else:
+            logging.warning("No buy signals found")
+        if not sell_signals.empty:
+            logging.debug(f"Adding {len(sell_signals)} sell signal markers")
+            fig.add_trace(go.Scatter(x=sell_signals[x_col], y=sell_signals['Price'], mode='markers', name='Sell', marker=dict(symbol='triangle-down', size=10, color='red')))
+        else:
+            logging.warning("No sell signals found")
         fig.update_layout(
             title=f"{ticker} Trading Signals",
             xaxis_title="Date",
@@ -468,14 +568,18 @@ def plot_signals(signals_df, ticker):
 
 def plot_backtest(result, df, ticker):
     try:
+        logging.debug(f"Starting plot_backtest for {ticker}")
         actual = result.get('actual', [])
         forecast = result.get('forecast', [])
         if len(actual) == 0 or len(forecast) == 0:
+            logging.warning("Actual or forecast data missing")
             return None
+        logging.debug(f"Actual length: {len(actual)}, Forecast length: {len(forecast)}")
         last_historical_date = df['Date'].iloc[-len(actual) - 1]
         historical_dates = df['Date'].iloc[-len(actual) - 1: -len(actual) + len(actual)]
         forecast_dates = pd.date_range(start=last_historical_date + timedelta(days=1), periods=len(forecast))
         historical_values = df['value'].iloc[-len(actual) - 1: -len(actual) + len(actual)]
+        logging.debug("Adding historical and forecast traces")
         fig = go.Figure()
         fig.add_trace(go.Scatter(x=historical_dates, y=historical_values, mode='lines', name='Historical', line=dict(color='blue')))
         fig.add_trace(go.Scatter(x=forecast_dates, y=forecast, mode='lines', name='Forecast', line=dict(color='orange', dash='dash')))
@@ -486,7 +590,8 @@ def plot_backtest(result, df, ticker):
             template="plotly_dark",
             showlegend=True
         )
+        logging.info(f"Backtest plot generated for {ticker}")
         return fig
     except Exception as e:
-        logging.error(f"Plot backtest error: {e}")
+        logging.error(f"Plot backtest error: {str(e)}")
         return None