Merge pull request #11 from betahub-io/ben/fixes

Ben/fixes

Author: genail

CLAUDE.md

@@ -0,0 +1,81 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a Unity plugin for BetaHub bug reporting that enables in-game bug submissions with video recording, screenshot capture, and log collection. The plugin is distributed as a Unity Package Manager (UPM) package.
+
+## Architecture
+
+### Core Components
+
+- **GameRecorder** (`Runtime/Scripts/GameRecorder.cs`): Handles video recording using FFmpeg with optimized GPU-based capture
+- **BugReportUI** (`Runtime/Scripts/BugReportUI.cs`): Main UI component for bug report submission form
+- **Issue** (`Runtime/Scripts/Issue.cs`): Data model representing bug reports and their upload state
+- **VideoEncoder** (`Runtime/Scripts/VideoEncoder.cs`): FFmpeg wrapper for video encoding with segmented recording
+- **Process Wrappers**: Platform-specific process handling for FFmpeg
+  - **IProcessWrapper** (`Runtime/Scripts/IProcessWrapper.cs`): Interface for process abstraction
+  - **DotNetProcessWrapper** (`Runtime/Scripts/DotNetProcessWrapper.cs`): .NET/Mono implementation
+  - **NativeProcessWrapper** (`Runtime/Scripts/NativeProcessWrapper.cs`): IL2CPP implementation using native library
+
+### Assembly Definitions
+
+- **Runtime**: `io.betahub.bugreporter.asmdef` - Main plugin runtime assembly
+- **Editor**: `io.betahub.bugreporter.editor.asmdef` - Editor-only features (FFmpeg downloader)
+
+### Platform Support
+
+The plugin supports Windows, macOS, and Linux with special handling for IL2CPP builds:
+- **Mono/.NET**: Uses standard .NET Process class
+- **IL2CPP**: Requires `ENABLE_BETAHUB_FFMPEG` scripting symbol and native process wrapper libraries in `Plugins/` directories
+
+### Native Libraries
+
+Platform-specific native libraries for IL2CPP FFmpeg support:
+- Windows: `Plugins/x86_64/betahub_process_wrapper.dll`
+- macOS: `Plugins/macOS/libbetahub_process_wrapper.dylib`
+- Linux: `Plugins/Linux/x86_64/libbetahub_process_wrapper.so`
+
+## Development
+
+### Unity Package Structure
+
+This project follows Unity Package Manager conventions:
+- `package.json`: Package metadata and dependencies
+- `Runtime/`: Runtime scripts and assets
+- `Editor/`: Editor-only scripts
+- `Samples~/`: Sample scenes and scripts
+- Assembly definition files (`.asmdef`) organize code into separate assemblies
+
+### Testing
+
+The plugin includes a working demo scene in `Samples~/ExampleScene/` with:
+- Sample scene setup
+- Example integration with `RotateCube.cs` script
+- Pre-configured demo project settings for immediate testing
+
+### FFmpeg Integration
+
+The plugin automatically downloads FFmpeg binaries through the editor script `FfmpegDownloader.cs`. Video recording is implemented with:
+- Segmented recording (10-second segments, 60-second rolling window)
+- GPU-optimized capture using RenderTextures
+- Cross-platform process wrapper abstraction
+- Error handling and retry logic for file operations
+
+## Configuration
+
+### Required Settings for IL2CPP
+
+When building with IL2CPP scripting backend:
+1. Define `ENABLE_BETAHUB_FFMPEG` in Player Settings > Scripting Define Symbols
+2. Ensure native process wrapper libraries are included in build
+
+### Demo Project
+
+The plugin comes pre-configured with demo project credentials (`DEMO_PROJECT_ID = "pr-5287510306"`) for immediate testing. Reports submitted to the demo project are only visible to the submitter via email links.
+
+## Development Notes
+
+- Do not generate meta files, let Unity do this
+- Use `ruby validate_prefab.rb <prefab_path>` to validate Unity prefabs for duplicate IDs and broken references

CLAUDE.md.meta

@@ -124,6 +124,8 @@ public class BugReportUI : MonoBehaviour
         private List<Issue.LogFileReference> _logFiles = new List<Issue.LogFileReference>();
 
         private static Logger _logger;
+        
+        public static Logger Logger => _logger;
         private bool _cursorStateChanged;
         private CursorLockMode _previousCursorLockMode;
 
@@ -402,7 +404,7 @@ private IEnumerator SubmitBugReportCoroutine()
                     // skip if size over 200MB
                     if (new FileInfo(_logger.LogPath).Length < 200 * 1024 * 1024)
                     {
-                        logFiles.Add(new Issue.LogFileReference { path = _logger.LogPath, removeAfterUpload = false });
+                        logFiles.Add(new Issue.LogFileReference { logger = _logger, removeAfterUpload = false });
                     }
                 }
             }
@@ -645,6 +647,26 @@ void OnDestroy()
             // Cleanup handled automatically since we don't subscribe to events
         }
 
+        public static void PauseLogger()
+        {
+#if !DISABLE_BETAHUB_LOGGER
+            if (_logger != null)
+            {
+                _logger.PauseLogging();
+            }
+#endif
+        }
+
+        public static void ResumeLogger()
+        {
+#if !DISABLE_BETAHUB_LOGGER
+            if (_logger != null)
+            {
+                _logger.ResumeLogging();
+            }
+#endif
+        }
+
         private void ValidateProviderCustomFields()
         {
             // Skip validation if we don't have the necessary credentials

Runtime/Scripts/BugReportUI.cs

@@ -46,6 +46,7 @@ public struct LogFileReference
         {
             public string path;
             public bool removeAfterUpload;
+            public Logger logger; // Optional: if set, use logger.ReadLogFileBytes() instead of path
         }
 
         public struct ScreenshotFileReference
@@ -214,19 +215,51 @@ public IEnumerator Publish(bool emailMyReport)
         // Helper method called after media upload completes
         private IEnumerator MarkMediaCompleteAndTryPublish()
         {
-            lock (this)
+            bool lockTaken = false;
+            try
             {
-                _mediaUploadComplete = true;
+                System.Threading.Monitor.TryEnter(this, 1000, ref lockTaken); // 1 second timeout
+                if (lockTaken)
+                {
+                    _mediaUploadComplete = true;
+                }
+                else
+                {
+                    Debug.LogWarning("Failed to acquire lock for MarkMediaCompleteAndTryPublish within timeout");
+                }
+            }
+            finally
+            {
+                if (lockTaken)
+                {
+                    System.Threading.Monitor.Exit(this);
+                }
             }
             yield return CheckAndPublishIfReady();
         }
 
         // Helper method called by the public Publish() method
         private IEnumerator RequestPublishAndTryPublish()
         {
-            lock (this)
+            bool lockTaken = false;
+            try
             {
-                _publishRequested = true;
+                System.Threading.Monitor.TryEnter(this, 1000, ref lockTaken); // 1 second timeout
+                if (lockTaken)
+                {
+                    _publishRequested = true;
+                }
+                else
+                {
+                    Debug.LogWarning("Failed to acquire lock for RequestPublishAndTryPublish within timeout");
+                }
+            }
+            finally
+            {
+                if (lockTaken)
+                {
+                    System.Threading.Monitor.Exit(this);
+                }
             }
             yield return CheckAndPublishIfReady();
         }
@@ -235,13 +268,29 @@ private IEnumerator RequestPublishAndTryPublish()
         private IEnumerator CheckAndPublishIfReady()
         {
             bool shouldPublish = false;
-            lock (this)
+            bool lockTaken = false;
+            try
+            {
+                System.Threading.Monitor.TryEnter(this, 1000, ref lockTaken); // 1 second timeout
+                if (lockTaken)
+                {
+                    // Check if publish is requested, media is done, not already published, and we have the necessary ID/token
+                    if (_publishRequested && _mediaUploadComplete && !_isPublished && !string.IsNullOrEmpty(Id) && !string.IsNullOrEmpty(_updateIssueAuthToken))
+                    {
+                        shouldPublish = true;
+                        _isPublished = true; // Prevent duplicate publish attempts
+                    }
+                }
+                else
+                {
+                    Debug.LogWarning("Failed to acquire lock for CheckAndPublishIfReady within timeout");
+                }
+            }
+            finally
             {
-                // Check if publish is requested, media is done, not already published, and we have the necessary ID/token
-                if (_publishRequested && _mediaUploadComplete && !_isPublished && !string.IsNullOrEmpty(Id) && !string.IsNullOrEmpty(_updateIssueAuthToken))
+                if (lockTaken)
                 {
-                    shouldPublish = true;
-                    _isPublished = true; // Prevent duplicate publish attempts
+                    System.Threading.Monitor.Exit(this);
                 }
             }
 
@@ -381,8 +430,25 @@ private IEnumerator PostScreenshot(ScreenshotFileReference screenshot)
 
         private IEnumerator PostLogFile(LogFileReference logFile)
         {
-            if (File.Exists(logFile.path))
+            if (logFile.logger != null)
             {
+                // Use logger's safe read method to avoid sharing violations
+                Debug.Log("Reading BetaHub log file safely using Logger instance");
+                byte[] fileData = logFile.logger.ReadLogFileBytes();
+
+                if (fileData != null)
+                {
+                    string fileName = Path.GetFileName(logFile.logger.LogPath) ?? "BH_Player.log";
+                    yield return UploadStringAsFile("log_files", "log_file[file]", fileData, fileName, "text/plain");
+                }
+                else
+                {
+                    Debug.LogError("Failed to read log file data from Logger instance");
+                }
+            }
+            else if (File.Exists(logFile.path))
+            {
+                // Original file path logic
                 yield return UploadFile("log_files", "log_file[file]", logFile.path, "text/plain");
 
                 if (logFile.removeAfterUpload)
@@ -409,9 +475,66 @@ private IEnumerator PostVideo(GameRecorder gameRecorder)
 
         private IEnumerator UploadFile(string endpoint, string fieldName, string filePath, string contentType)
         {
+            bool isLogFile = Path.GetExtension(filePath).Equals(".log", StringComparison.OrdinalIgnoreCase);
+            byte[] fileData;
+            
+            if (isLogFile)
+            {
+                if (BugReportUI.Logger != null && filePath == BugReportUI.Logger.LogPath)
+                {
+                    Debug.Log("Reading log file safely using Logger instance");
+                    fileData = BugReportUI.Logger.ReadLogFileBytes();
+                    if (fileData == null)
+                    {
+                        Debug.LogError("Failed to read log file data from Logger instance");
+                        yield break;
+                    }
+                }
+                else
+                {
+                    BugReportUI.PauseLogger();
+                    
+                    try
+                    {
+                        fileData = File.ReadAllBytes(filePath);
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug.LogError($"Error reading file {filePath}: {ex.Message}");
+                        BugReportUI.ResumeLogger();
+                        yield break;
+                    }
+                    
+                    BugReportUI.ResumeLogger();
+                }
+            }
+            else
+            {
+                // For non-log files, read normally
+                try
+                {
+                    fileData = File.ReadAllBytes(filePath);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError($"Error reading file {filePath}: {ex.Message}");
+                    yield break;
+                }
+            }
+            
+            yield return UploadStringAsFile(endpoint, fieldName, fileData, Path.GetFileName(filePath), contentType);
+        }
+
+        private IEnumerator UploadStringAsFile(string endpoint, string fieldName, byte[] fileData, string fileName, string contentType)
+        {
+            if (fileData == null)
+            {
+                Debug.LogError($"Cannot upload {fileName}: file data is null");
+                yield break;
+            }
+
             WWWForm form = new WWWForm();
-            byte[] fileData = File.ReadAllBytes(filePath);
-            form.AddBinaryData(fieldName, fileData, Path.GetFileName(filePath), contentType);
+            form.AddBinaryData(fieldName, fileData, fileName, contentType);
 
             string url = $"{_betahubEndpoint}projects/{_projectId}/issues/g-{Id}/{endpoint}";
             using (UnityWebRequest www = UnityWebRequest.Post(url, form))
@@ -424,11 +547,11 @@ private IEnumerator UploadFile(string endpoint, string fieldName, string filePat
 
                 if (www.result != UnityWebRequest.Result.Success)
                 {
-                    Debug.LogError($"Error uploading {Path.GetFileName(filePath)}: {www.error}");
+                    Debug.LogError($"Error uploading {fileName}: {www.error}");
                 }
                 else
                 {
-                    Debug.Log($"{Path.GetFileName(filePath)} uploaded successfully!");
+                    Debug.Log($"{fileName} uploaded successfully!");
                 }
             }
         }