Complete Error Tracking Example

# game_manager.gd
extends Node
 
func _ready():
    print("Error tracking ready")
 
func _on_connection_failed(error_code: int):
    ShardSDK.monitor.report_error(
        "Failed to connect to server: error code " + str(error_code)
    )
 
func _on_save_corrupted(file_path: String):
    ShardSDK.monitor.report_error(
        "Save file corrupted: " + file_path
    )

// GameManager.cs
using Shard;
using UnityEngine;
 
public class GameManager : MonoBehaviour
{
    void Start()
    {
        Debug.Log("Error tracking ready");
    }
 
    void OnConnectionFailed(int errorCode)
    {
        ShardSDK.Monitor.ReportError(
            $"Failed to connect to server: error code {errorCode}"
        );
    }
 
    void OnSaveCorrupted(string filePath)
    {
        ShardSDK.Monitor.ReportError(
            $"Save file corrupted: {filePath}"
        );
    }
}

// GameManager.cs
using Shard;
 
public class GameManager
{
    public void Initialize()
    {
        ShardSDK.Initialize();
        Console.WriteLine("Error tracking ready");
    }
 
    void OnConnectionFailed(int errorCode)
    {
        ShardSDK.Monitor.ReportError(
            $"Failed to connect to server: error code {errorCode}"
        );
    }
 
    void OnSaveCorrupted(string filePath)
    {
        ShardSDK.Monitor.ReportError(
            $"Save file corrupted: {filePath}"
        );
    }
}

// obj_game_manager Create event
show_debug_message("Error tracking ready");

// Script: scr_on_connection_failed
function on_connection_failed(error_code) {
    shard_monitor_report(
        "Failed to connect to server: error code " + string(error_code)
    );
}

// Script: scr_on_save_corrupted
function on_save_corrupted(file_path) {
    shard_monitor_report(
        "Save file corrupted: " + file_path
    );
}

// In a custom plugin or script call
console.log("Error tracking ready");
 
function onConnectionFailed(errorCode) {
    ShardSDK.Monitor.reportError(
        "Failed to connect to server: error code " + errorCode
    );
}
 
function onSaveCorrupted(filePath) {
    ShardSDK.Monitor.reportError(
        "Save file corrupted: " + filePath
    );
}

# network_manager.gd
extends Node
 
func _on_http_request_completed(result: int, response_code: int, headers: PackedStringArray, body: PackedByteArray):
    if result != HTTPRequest.RESULT_SUCCESS:
        ShardSDK.monitor.report_error(
            "HTTP request failed with result: " + str(result)
        )
    elif response_code >= 400:
        ShardSDK.monitor.report_error(
            "HTTP error response: " + str(response_code)
        )
 
func _on_websocket_error(error_message: String):
    ShardSDK.monitor.report_error("WebSocket error: " + error_message)

// NetworkManager.cs
using Shard;
using UnityEngine;
using UnityEngine.Networking;
 
public class NetworkManager : MonoBehaviour
{
    IEnumerator MakeRequest(string url)
    {
        using (UnityWebRequest request = UnityWebRequest.Get(url))
        {
            yield return request.SendWebRequest();
            
            if (request.result != UnityWebRequest.Result.Success)
            {
                ShardSDK.Monitor.ReportError(
                    $"HTTP request failed: {request.error}"
                );
            }
        }
    }
 
    void OnWebSocketError(string errorMessage)
    {
        ShardSDK.Monitor.ReportError($"WebSocket error: {errorMessage}");
    }
}

// Async HTTP event
if (async_load[? "status"] < 0) {
    shard_monitor_report(
        "HTTP request failed with status: " + string(async_load[? "status"])
    );
}

# exception_handler.gd
extends Node
 
func safe_call(callable: Callable) -> Variant:
    # Note: GDScript doesn't have try/catch, but you can capture errors
    # through push_error and custom error handling
    var result = callable.call()
    return result
 
func report_with_stack(message: String):
    var stack = get_stack()
    var stack_str = ""
    for frame in stack:
        stack_str += "%s:%d in %s\n" % [frame.source, frame.line, frame.function]
    ShardSDK.monitor.report_error(message, stack_str)

// ExceptionHandler.cs
using Shard;
using System;
 
public class ExceptionHandler
{
    public static void SafeCall(Action action)
    {
        try
        {
            action();
        }
        catch (Exception ex)
        {
            ShardSDK.Monitor.ReportError(ex.Message, ex.StackTrace);
        }
    }
 
    public static T SafeCall<T>(Func<T> func, T defaultValue = default)
    {
        try
        {
            return func();
        }
        catch (Exception ex)
        {
            ShardSDK.Monitor.ReportError(ex.Message, ex.StackTrace);
            return defaultValue;
        }
    }
}
 
// Usage
ExceptionHandler.SafeCall(() => {
    // risky code here
});

// exception_handler.js
function safeCall(fn) {
    try {
        return fn();
    } catch (e) {
        ShardSDK.Monitor.reportError(e.message, e.stack);
        return null;
    }
}
 
// Usage
safeCall(() => {
    // risky code here
});

func load_save_file(path: String) -> Dictionary:
    if not FileAccess.file_exists(path):
        ShardSDK.monitor.report_error("Save file not found: " + path)
        return {}
    
    var file = FileAccess.open(path, FileAccess.READ)
    if file == null:
        ShardSDK.monitor.report_error(
            "Failed to open save file: " + str(FileAccess.get_open_error())
        )
        return {}
    
    var json = JSON.new()
    var parse_result = json.parse(file.get_as_text())
    if parse_result != OK:
        ShardSDK.monitor.report_error(
            "Failed to parse save file: " + json.get_error_message()
        )
        return {}
    
    return json.data

public SaveData LoadSaveFile(string path)
{
    if (!File.Exists(path))
    {
        ShardSDK.Monitor.ReportError($"Save file not found: {path}");
        return null;
    }
 
    try
    {
        string json = File.ReadAllText(path);
        return JsonUtility.FromJson<SaveData>(json);
    }
    catch (Exception ex)
    {
        ShardSDK.Monitor.ReportError(
            $"Failed to load save file: {ex.Message}",
            ex.StackTrace
        );
        return null;
    }
}

func load_texture(path: String) -> Texture2D:
    var texture = load(path) as Texture2D
    if texture == null:
        ShardSDK.monitor.report_error("Failed to load texture: " + path)
    return texture

public Texture2D LoadTexture(string path)
{
    var texture = Resources.Load<Texture2D>(path);
    if (texture == null)
    {
        ShardSDK.Monitor.ReportError($"Failed to load texture: {path}");
    }
    return texture;
}

# Report error
ShardSDK.monitor.report_error(message)
ShardSDK.monitor.report_error(message, stack_trace)

// Report error
ShardSDK.Monitor.ReportError(message);
ShardSDK.Monitor.ReportError(message, stackTrace);

// Report error
ShardSDK.Monitor.ReportError(message);
ShardSDK.Monitor.ReportError(message, stackTrace);

// Report error
shard_monitor_report(message);
shard_monitor_report(message, stack_trace);

// Report error
ShardSDK.Monitor.reportError(message);
ShardSDK.Monitor.reportError(message, stackTrace);