Merge remote-tracking branch 'origin/dev-logger-fix' into ben/fixes

Author: b3ncr0w

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

Runtime/Scripts/BugReportUI.cs

@@ -402,7 +402,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 });
                     }
                 }
             }

Runtime/Scripts/Issue.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
@@ -381,8 +382,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)
@@ -459,6 +477,37 @@ private IEnumerator UploadFile(string endpoint, string fieldName, string filePat
             }
         }
 
+        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();
+            form.AddBinaryData(fieldName, fileData, fileName, contentType);
+
+            string url = $"{_betahubEndpoint}projects/{_projectId}/issues/g-{Id}/{endpoint}";
+            using (UnityWebRequest www = UnityWebRequest.Post(url, form))
+            {
+                www.SetRequestHeader("Authorization", "Bearer " + _updateIssueAuthToken);
+                www.SetRequestHeader("BetaHub-Project-ID", _projectId);
+                www.SetRequestHeader("Accept", "application/json");
+
+                yield return www.SendWebRequest();
+
+                if (www.result != UnityWebRequest.Result.Success)
+                {
+                    Debug.LogError($"Error uploading {fileName}: {www.error}");
+                }
+                else
+                {
+                    Debug.Log($"{fileName} uploaded successfully!");
+                }
+            }
+        }
+
         private IEnumerator PublishNow()
         {
             // Ensure we have valid parameters before proceeding

Runtime/Scripts/Logger.cs

@@ -156,6 +156,63 @@ public void ResumeLogging()
             }
         }
 
+        /// <summary>
+        /// Safely reads the entire log file by temporarily closing the file stream.
+        /// This prevents file sharing violations when other parts of the application need to read the log.
+        /// </summary>
+        /// <returns>The complete log file content as a byte array, or null if an error occurs</returns>
+        public byte[] ReadLogFileBytes()
+        {
+            if (disposed || string.IsNullOrEmpty(_logPath))
+            {
+                Debug.LogWarning("Cannot read log file: Logger is disposed or log path is not set");
+                return null;
+            }
+
+            lock (lockObject)
+            {
+                try
+                {
+                    // First, flush any buffered data
+                    FlushBuffer();
+
+                    // Temporarily close the file streams
+                    writer?.Dispose();
+                    fileStream?.Dispose();
+                    writer = null;
+                    fileStream = null;
+
+                    // Now we can safely read the file since we've closed our handle
+                    byte[] fileData = null;
+                    if (File.Exists(_logPath))
+                    {
+                        fileData = File.ReadAllBytes(_logPath);
+                    }
+
+                    // Reopen the file streams to continue logging
+                    InitializeFileStream();
+
+                    return fileData;
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError("Error reading log file: " + e.Message);
+
+                    // Ensure we reopen the file streams even if reading failed
+                    try
+                    {
+                        InitializeFileStream();
+                    }
+                    catch (Exception reopenEx)
+                    {
+                        Debug.LogError("Error reopening log file after failed read: " + reopenEx.Message);
+                    }
+
+                    return null;
+                }
+            }
+        }
+
         public void Dispose()
         {
             if (disposed) return;