feat(database): added logger and create to a new database method

app.py

@@ -1,8 +1,12 @@
 from fastapi import FastAPI
 from controller import Controller
+from database import Database
+import logging
 
 app = FastAPI()
-controller = Controller()
+database = Database()
+
+logger = logging.getLogger(__name__)
 
 @app.get("/")
 def greet_json():
@@ -10,4 +14,79 @@ def greet_json():
 
 @app.get("/predict-machine")
 def predict_machine():
-    return controller.predict_binary()
+    logger.info("Prediction request received")
+    
+    sensor = database.get_sensor_readings()
+    
+    if sensor is None:
+        logging.warning("No sensor data available")
+        return {
+            "success": False,
+            "error": "No sensor data available"
+        }
+        
+    sensor_udi = sensor.get("udi")
+    
+    logger.debug(f"Processing sensor data for machine_id: {sensor.get('machine_id')}")
+    
+    controller = Controller(database_sensor=sensor)
+    
+    binary_result = controller.predict_binary()
+    if not binary_result.get("success"):
+        logger.error(f"Binary prediction failed: {binary_result.get('error')}")
+        database.reset_last_processed_id()
+        return binary_result
+    
+    if binary_result.get("failure_predicted"):
+        logger.info("Failure predicted - running classification and time series analysis")
+        classification_result = controller.predict_classification()
+        time_series_result = controller.predict_time_series()
+        
+        if classification_result.get("success") and time_series_result.get("success"):
+            logger.info(f"Prediction successful - failure_type: {classification_result.get('failure_type')}")
+            
+            save_result = database.create_new_predictions(
+                machine_id=sensor.get("machine_id"),
+                timestamp=sensor.get("timestamp"),
+                risk_score=classification_result.get("risk_score"),
+                failure_predicted=True,
+                failure_type=classification_result.get("failure_type"),
+                predicted_failure_time=time_series_result.get("predictions", {}).get("predicted_timestamp"),
+                confidence=classification_result.get("confidence")
+            )
+            
+            if save_result is None or save_result.get("error"):
+                logger.error(f"Failed to save prediction for UDI {sensor_udi} - resetting for retry")
+                database.reset_last_processed_id()
+                return {
+                    "success": False,
+                    "error": "Failed to save prediction to database"
+                }
+            logger.info(f"Prediction successfully saved for UDI {sensor_udi}")
+            return {
+                "success": True,
+                "failure_predicted": True,
+                "failure_type": classification_result.get("failure_type"),
+                "confidence": classification_result.get("confidence"),
+                "risk_score": classification_result.get("risk_score"),
+                "risk_level": classification_result.get("risk_level"),
+                "all_probabilities": classification_result.get("all_probabilities"),
+                "prediction_time_stamp": time_series_result.get("predictions"),
+                "timestamp": sensor.get("timestamp")
+            }
+        else:
+            logger.error(f"Classification or time series prediction failed for UDI {sensor_udi}")
+            database.reset_last_processed_id()
+            
+            return binary_result
+    else: 
+        database.create_new_predictions(
+            machine_id=sensor.get("machine_id"),
+            timestamp=sensor.get("timestamp"),
+            risk_score=binary_result.get("risk_score"),
+            failure_predicted=binary_result.get("failure_predicted"),
+            failure_type=NULL,
+            predicted_failure_time=NULL,
+            confidence=binary_result.get("confidence")
+        )
+        return binary_result

controller.py

@@ -1,217 +1,241 @@
+import logging
+
 from database import Database
 from model import Model
 from utils import (
+    calculate_risk_score,
     convert_cyclical_to_original,
     create_timestamp_from_predictions,
-    prepare_prediction_data,
-    prepare_sensor_data_for_anomaly,
-    calculate_risk_score,
-    get_risk_level,
     get_failure_severity,
     get_failure_type_name,
+    get_risk_level,
+    prepare_prediction_data,
+    prepare_sensor_data_for_anomaly,
 )
 
-from datetime import datetime
+logger = logging.getLogger(__name__)
+
 
 class Controller:
-    def __init__(self):
-        self.__database = Database()
-        self.__sensor = self.__database.get_sensor_readings()
+    def __init__(self, database_sensor):
+        Database()
+        self.__sensor = database_sensor
         self.__model = Model()
-        
-    def _get_hardcoded_error_sensor(self):
-        """Hardcoded sensor data yang pasti error untuk testing"""
-        return {
-            "id": 9999,
-            "air_temp": 298.9,
-            "process_temp": 309.1,
-            "rotational_speed": 2861,
-            "torque": 4.6,
-            "tool_wear": 143,
-            "timestamp": datetime.now(),
-            "created_at": datetime.now()
-        }
+    
     # Binary method
     def predict_binary(self):
         if self.__sensor is None:
+            logger.warning("Binary prediction attempted with no sensor data")
             return {
                 "success": False,
                 "error": "No sensor data available from database.",
             }
-
+        
+        if self.__sensor.get("message") == "Data already predicted":
+            logger.info(f"Skipping binary prediction - data already predicted for UDI: {self.__sensor.get('udi')}")
+            return {
+                "success": False,
+                "error": "Data already predicted",
+            }
+        
         if (
             self.__model.model_binary is None
             or self.__model.preprocessor_anomaly is None
         ):
+            logger.error("Binary model or preprocessor not loaded - cannot perform prediction")
             return {
                 "success": False,
                 "error": "Binary model or preprocessor not loaded.",
             }
-
-        X_scaled = prepare_sensor_data_for_anomaly(
-            self.__sensor, self.__model.preprocessor_anomaly
-        )
-
-        if X_scaled is None:
-            return {"success": False, "error": "Failed to prepare sensor data."}
-
-        if hasattr(self.__model.model_binary, "predict_proba"):
-            probabilities = self.__model.model_binary.predict_proba(X_scaled)[0]
-            confidence_normal = float(probabilities[0])
-            confidence_error = float(probabilities[1])
             
-            is_error = int(confidence_error > 0.5)
-            confidence = confidence_error if is_error else confidence_normal
-        else:
-            prediction = self.__model.model_binary.predict(X_scaled)
-            is_error = int(prediction[0])
-            confidence = 1.0 if is_error else 0.0
-
-        risk_score = confidence * 100 if is_error else (1 - confidence) * 100
-
-        result = {
-            "success": True,
-            "failure_predicted": bool(is_error),
-            "confidence": float(f"{confidence}"),
-            "risk_score": float(f"{risk_score}"),
-            "sensor_data": {
-                "air_temp": self.__sensor.get("air_temp"),
-                "process_temp": self.__sensor.get("process_temp"),
-                "rotational_speed": self.__sensor.get("rotational_speed"),
-                "torque": self.__sensor.get("torque"),
-                "tool_wear": self.__sensor.get("tool_wear"),
-            },
-        }
-
-        if is_error:
-            multiclass_result = self.predict_classification()
-            if multiclass_result.get("success"):
-                result["failure_analysis"] = {
-                    "failure_type": multiclass_result.get("failure_type"),
-                    "confidence": multiclass_result.get("confidence"),
-                    "risk_level": multiclass_result.get("risk_level"),
-                    "risk_score": multiclass_result.get("risk_score"),
-                    "all_probabilities": multiclass_result.get("all_probabilities"),
-                }
-        else:
-            result["failure_analysis"] = {
-                "failure_type": "No Failure",
-                "risk_level": "Very Low",
+        try:
+            X_scaled = prepare_sensor_data_for_anomaly(
+                self.__sensor, self.__model.preprocessor_anomaly
+            )
+    
+            if X_scaled is None:
+                logger.error("Failed to prepare sensor data for binary prediction")
+                return {"success": False, "error": "Failed to prepare sensor data."}
+    
+            if hasattr(self.__model.model_binary, "predict_proba"):
+                probabilities = self.__model.model_binary.predict_proba(X_scaled)[0]
+                confidence_normal = float(probabilities[0])
+                confidence_error = float(probabilities[1])
+                
+                is_error = int(confidence_error > 0.5)
+                confidence = confidence_error if is_error else confidence_normal
+            else:
+                prediction = self.__model.model_binary.predict(X_scaled)
+                is_error = int(prediction[0])
+                confidence = 1.0 if is_error else 0.0
+    
+            risk_score = confidence * 100 if is_error else (1 - confidence) * 100
+    
+            logger.info(f"Binary prediction complete - Failure: {bool(is_error)}, Confidence: {confidence:.2f}, Risk: {risk_score:.2f}")
+            
+            result = {
+                "success": True,
+                "failure_predicted": bool(is_error),
+                "confidence": float(f"{confidence}"),
+                "risk_score": float(f"{risk_score}"),
+            }
+            return result
+        except Exception as e:
+            logger.error(f"Exception in binary prediction: {str(e)}")
+            return {
+                "success": False,
+                "message": f"Failed to predict binary data: {str(e)}"
             }
-
-        return result
 
     # Classification Method
     def predict_classification(self):
         if self.__sensor is None:
+            logger.warning("Classification prediction attempted with no sensor data")
             return {
                 "success": False,
                 "error": "No sensor data available from database.",
             }
+        
+        if self.__sensor.get("message") == "Data already predicted":
+            logger.info(f"Skipping classification prediction - data already predicted for UDI: {self.__sensor.get('udi')}")
+            return {
+                "success": False,
+                "error": "Data already predicted",
+            }
 
         if (
             self.__model.model_multiclass is None
             or self.__model.preprocessor_anomaly is None
         ):
+            logger.error("Multiclass model or preprocessor not loaded - cannot perform prediction")
             return {"success": False, "error": "Model or scalers not loaded."}
-
-        X_scaled = prepare_sensor_data_for_anomaly(
-            self.__sensor, self.__model.preprocessor_anomaly
-        )
-
-        if X_scaled is None:
-            return {"success": False, "error": "Failed to prepare sensor data."}
-
-        prediction = self.__model.model_multiclass.predict(X_scaled)
-
-        if hasattr(self.__model.model_multiclass, "predict_proba"):
-            probabilities = self.__model.model_multiclass.predict_proba(X_scaled)[0]
-            failure_index = int(probabilities.argmax())
-            confidence = float(probabilities[failure_index])
-
-            all_probs = {
-                get_failure_type_name(i): float(prob)
-                for i, prob in enumerate(probabilities)
+        
+        try:
+            X_scaled = prepare_sensor_data_for_anomaly(
+                self.__sensor, self.__model.preprocessor_anomaly
+            )
+    
+            if X_scaled is None:
+                logger.error("Failed to prepare sensor data for classification prediction")
+                return {"success": False, "error": "Failed to prepare sensor data."}
+    
+            prediction = self.__model.model_multiclass.predict(X_scaled)
+    
+            if hasattr(self.__model.model_multiclass, "predict_proba"):
+                probabilities = self.__model.model_multiclass.predict_proba(X_scaled)[0]
+                failure_index = int(probabilities.argmax())
+                confidence = float(probabilities[failure_index])
+    
+                all_probs = {
+                    get_failure_type_name(i): float(prob)
+                    for i, prob in enumerate(probabilities)
+                }
+            else:
+                failure_index = int(prediction[0])
+                confidence = 1.0
+                all_probs = None
+    
+            failure_type = get_failure_type_name(failure_index)
+    
+            severity = get_failure_severity(failure_index)
+            risk_score = calculate_risk_score(confidence, severity)
+            risk_level = get_risk_level(risk_score)
+    
+            logger.info(f"Classification prediction complete - Failure Type: {failure_type}, Confidence: {confidence:.2f}, Risk Level: {risk_level}, Risk Score: {risk_score:.2f}")
+            
+            return {
+                "success": True,
+                "failure_type": failure_type,
+                "confidence": float(f"{confidence}"),
+                "risk_score": float(f"{risk_score}"),
+                "risk_level": risk_level,
+                "all_probabilities": all_probs,
+            }
+        except Exception as e:
+            logger.error(f"Exception in classification prediction: {str(e)}")
+            return {
+                "success": False,
+                "message": f"Failed to predict classification data: {str(e)}"
             }
-        else:
-            failure_index = int(prediction[0])
-            confidence = 1.0
-            all_probs = None
-
-        failure_type = get_failure_type_name(failure_index)
-
-        severity = get_failure_severity(failure_index)
-        risk_score = calculate_risk_score(confidence, severity)
-        risk_level = get_risk_level(risk_score)
-
-        return {
-            "success": True,
-            "failure_type": failure_type,
-            "confidence": float(f"{confidence}"),
-            "risk_score": float(f"{risk_score}"),
-            "risk_level": risk_level,
-            "all_probabilities": all_probs,
-        }
 
     # Time series method
     def predict_time_series(self):
         if self.__sensor is None:
+            logger.warning("Time series prediction attempted with no sensor data")
             return {
                 "success": False,
                 "error": "No sensor data available from database.",
             }
+        
+        if self.__sensor.get("message") == "Data already predicted":
+            logger.info(f"Skipping time series prediction - data already predicted for UDI: {self.__sensor.get('udi')}")
+            return {
+                "success": False,
+                "error": "Data already predicted",
+            }
 
         if (
             self.__model.model_lstm is None
             or self.__model.scaler_x is None
             or self.__model.scaler_y is None
         ):
+            logger.error("LSTM model or scalers not loaded - cannot perform prediction")
             return {"success": False, "error": "Model or scalers not loaded."}
-
-        timestamp = self.__sensor.get("timestamp", None)
-
-        X_sequence = prepare_prediction_data(
-            self.__sensor, timestamp, self.__model.scaler_x, 32
-        )
-
-        if X_sequence is None:
-            return {"success": False, "error": "Failed to prepare prediction data."}
-
-        scaled_prediction = self.__model.model_lstm.predict(X_sequence, verbose=0)
-
-        prediction = self.__model.scaler_y.inverse_transform(scaled_prediction)
-
-        pred_values = prediction[0]
-        original_values = convert_cyclical_to_original(
-            pred_values[0],  # hour_sin
-            pred_values[1],  # hour_cos
-            pred_values[2],  # dayofweek_sin
-            pred_values[3],  # dayofweek_cos
-            pred_values[4],  # dayofyear_sin
-            pred_values[5],  # dayofyear_cos
-            pred_values[6],  # month_sin
-            pred_values[7],  # month_cos
-        )
-
-        predicted_timestamp = create_timestamp_from_predictions(
-            original_values, self.__sensor.get("timestamp", None)
-        )
-
-        return {
-            "success": True,
-            "predictions": {
-                "hour": original_values["hour"],
-                "dayofweek": original_values["dayofweek"],
-                "dayofyear": original_values["dayofyear"],
-                "month": original_values["month"],
-                "predicted_timestamp": predicted_timestamp,
-            },
-            "raw_sensor_data": {
-                "air_temp": self.__sensor.get("air_temp"),
-                "process_temp": self.__sensor.get("process_temp"),
-                "rotational_speed": self.__sensor.get("rotational_speed"),
-                "torque": self.__sensor.get("torque"),
-                "tool_wear": self.__sensor.get("tool_wear"),
-            },
-            "input_timestamp": str(timestamp),
-        }
+            
+        try:
+            timestamp = self.__sensor.get("timestamp", None)
+    
+            X_sequence = prepare_prediction_data(
+                self.__sensor, timestamp, self.__model.scaler_x, 32
+            )
+    
+            if X_sequence is None:
+                logger.error("Failed to prepare prediction data for time series")
+                return {"success": False, "error": "Failed to prepare prediction data."}
+    
+            scaled_prediction = self.__model.model_lstm.predict(X_sequence, verbose=0)
+    
+            prediction = self.__model.scaler_y.inverse_transform(scaled_prediction)
+    
+            pred_values = prediction[0]
+            original_values = convert_cyclical_to_original(
+                pred_values[0],  # hour_sin
+                pred_values[1],  # hour_cos
+                pred_values[2],  # dayofweek_sin
+                pred_values[3],  # dayofweek_cos
+                pred_values[4],  # dayofyear_sin
+                pred_values[5],  # dayofyear_cos
+                pred_values[6],  # month_sin
+                pred_values[7],  # month_cos
+            )
+    
+            predicted_timestamp = create_timestamp_from_predictions(
+                original_values, self.__sensor.get("timestamp", None)
+            )
+    
+            logger.info(f"Time series prediction complete - Predicted Timestamp: {predicted_timestamp}, Hour: {original_values['hour']}, Day of Week: {original_values['dayofweek']}")
+            
+            return {
+                "success": True,
+                "predictions": {
+                    "hour": original_values["hour"],
+                    "dayofweek": original_values["dayofweek"],
+                    "dayofyear": original_values["dayofyear"],
+                    "month": original_values["month"],
+                    "predicted_timestamp": predicted_timestamp,
+                },
+                "raw_sensor_data": {
+                    "air_temp": self.__sensor.get("air_temp"),
+                    "process_temp": self.__sensor.get("process_temp"),
+                    "rotational_speed": self.__sensor.get("rotational_speed"),
+                    "torque": self.__sensor.get("torque"),
+                    "tool_wear": self.__sensor.get("tool_wear"),
+                },
+                "input_timestamp": str(timestamp),
+            }
+        except Exception as e:
+            logger.error(f"Exception in time series prediction: {str(e)}")
+            return {
+                "success": False,
+                "message": f"Failed to predict time-series data: {str(e)}"
+            }

database.py

@@ -1,8 +1,10 @@
 import os
+import logging
 from dotenv import load_dotenv
 from supabase import create_client, Client
 
 load_dotenv()
+logger = logging.getLogger(__name__)
 
 class Database():
     def __init__(self):
@@ -10,19 +12,69 @@ class Database():
         self.__key: str = os.environ.get("SUPABASE_KEY") or ""
         
         if not self.__url or not self.__key:
+            logger.critical("SUPABASE_URL or SUPABASE_KEY is missing in environment")
             raise ValueError("SUPABASE_URL or SUPABASE_KEY is missing in environment")
-            
-        self.__supabase: Client = create_client(self.__url, self.__key)
+        
+        try:
+            self.__supabase: Client = create_client(self.__url, self.__key)
+            self.__last_processed_id = None
+            logger.info("Database connection established successfully")
+        except Exception as e:
+            logger.critical(f"Failed to create Supabase client: {str(e)}")
+            raise
+    
+    def reset_last_processed_id(self):
+        self.__last_processed_id = None
+        logger.info("Reset last_processed_id - data can be reprocessed")
 
+    
     def get_sensor_readings(self):
-        response = (
-            self.__supabase.table("sensor_readings")
-            .select("*")
-            .order("created_at", desc=True)
-            .limit(1)
-            .execute()
-        )
-        
-        if response.data:
-            return response.data[0]
-        return None
+        try:
+            response = (
+                self.__supabase.table("sensor_readings")
+                .select("*")
+                .order("created_at", desc=True)
+                .limit(1)
+                .execute()
+            )
+            
+            if response.data:
+                current_reading = response.data[0]
+                
+                if self.__last_processed_id == current_reading.get("udi"):
+                    logger.warning(f"Duplicate data detected - UDI {current_reading.get('udi')} already processed")
+                    return {
+                        "success": False,
+                        "message": "Data already predicted",
+                    }
+                
+                self.__last_processed_id = current_reading.get("udi")
+                logger.debug(f"Retrieved sensor reading - UDI: {current_reading.get('udi')}, Machine: {current_reading.get('machine_id')}")
+                return current_reading
+            
+            logger.warning("No sensor readings found in database")
+            return None
+        except Exception as e:
+            logger.error(f"Failed to retrieve sensor readings: {str(e)}")
+            return None
+    
+    def create_new_predictions(self, machine_id, timestamp, risk_score, failure_predicted, failure_type, predicted_failure_time, confidence):
+        try:
+            response = (
+                self.__supabase.table("prediction_results")
+                .insert({
+                    "machine_id": machine_id,
+                    "timestamp": timestamp,
+                    "risk_score": risk_score,
+                    "failure_predicted": failure_predicted,
+                    "failure_type": failure_type,
+                    "predicted_failure_time": predicted_failure_time,
+                    "confidence": confidence
+                })
+                .execute()
+            )
+            logger.info(f"Prediction saved - Machine: {machine_id}, Failure: {failure_predicted}, Risk: {risk_score}")
+            return {"success": True, "data": response}
+        except Exception as e:
+            logger.error(f"Failed to save prediction to database: {str(e)}")
+            return {"success": False, "error": str(e)}