Updated extension to only connect when relevant tabs are present (ArgLab#235)

* updated extension to only connect when relevant tabs are present

* updated urls

* added terminate event to the server to close files

Author: bradley-erickson

VERSION

@@ -1 +1 @@
-0.1.0+2025.09.18T20.00.55.977Z.4d8e2b48.berickson.2025.document.restructure
+0.1.0+2025.09.15T18.58.19.025Z.cb6381ff.berickson.202509.extension.fixes

extension/writing-process/src/background.js

@@ -28,34 +28,54 @@ import { localStorageInfo, sessionStorageInfo } from 'lo_event/lo_event/metadata
 // } /* and other async logic */);
 // websocketLogger( callback );
 
+// Track which tabs currently have an active content script and the state of
+// our logger so that we only initialize logging when needed.
+const activeContentTabs = new Set();
+let loEventActive = false;
+let loggers = [];
+const manifestVersion = chrome.runtime.getManifest().version;
+
+
 // We are not sure if this should be done within `websocketLogger()`'s `init`
 // or one level up. 
-const loggers = [
-  consoleLogger(),
-  websocketLogger(WEBSOCKET_SERVER_URL)
-]
-
-loEvent.init(
-    'org.mitros.writing_analytics',
-    '0.01',
-    loggers,
-    {
-        debugLevel: loEventDebug.LEVEL.SIMPLE,
-        metadata: [
-            browserInfo(),
-            chromeAuth(),
-            localStorageInfo(),
-            sessionStorageInfo(),
-        ]
-    }
-);
-loEvent.go();
+function startLogger () {
+    if (loEventActive) return;
+    loggers = [
+        consoleLogger(),
+        websocketLogger(WEBSOCKET_SERVER_URL)
+    ];
+    loEvent.init(
+        'org.mitros.writing_analytics',
+        manifestVersion,
+        loggers,
+        {
+            debugLevel: loEventDebug.LEVEL.SIMPLE,
+            // TODO document what we have currently and what we want
+            metadata: [
+                browserInfo(),
+                chromeAuth(),
+                localStorageInfo(),
+                sessionStorageInfo(),
+            ]
+        }
+    );
+    loEvent.go();
+    loEventActive = true;
+    loEvent.logEvent('extension_loaded', {});
+    logFromServiceWorker('Extension loaded');
+}
+
+function stopLogger () {
+    if (!loEventActive) return;
+    loEvent.logEvent('terminate', {});
+    loEventActive = false;
+}
 
 // Function to serve as replacement for 
 // chrome.extension.getBackgroundPage().console.log(event); because it is not allowed in V3
 // It logs the event to the console for debugging.
 function logFromServiceWorker(event) {
-  console.log(event);
+    console.log(event);
 }
 
 function this_a_google_docs_save(request) {
@@ -69,7 +89,7 @@ function this_a_google_docs_save(request) {
        went from a conservative regexp to a liberal one. We should
        confirm this never catches extra requests, though.
     */
-    if(request.url.match(/.*:\/\/docs\.google\.com\/document\/(.*)\/save/i)) {
+    if (request.url.match(/.*:\/\/docs\.google\.com\/document\/(.*)\/save/i)) {
         return true;
     }
     return false;
@@ -85,7 +105,7 @@ function this_a_google_docs_bind(request) {
 
       https://stackoverflow.com/questions/6831916/is-it-possible-to-monitor-http-traffic-in-chrome-using-an-extension#6832018
     */
-    if(request.url.match(/.*:\/\/docs\.google\.com\/document\/(.*)\/bind/i)) {
+    if (request.url.match(/.*:\/\/docs\.google\.com\/document\/(.*)\/bind/i)) {
         return true;
     }
     return false;
@@ -106,10 +126,29 @@ chrome.storage.sync.get(['process_server'], function(result) {
 
 // Listen for the keystroke messages from the page script and forward to the server.
 chrome.runtime.onMessage.addListener(
-    function(request, sender, sendResponse) {
-        //chrome.extension.getBackgroundPage().console.log("Got message");
-        //chrome.extension.getBackgroundPage().console.log(request);
-        //console.log(sender);
+    function (request, sender, sendResponse) {
+        // Lifecycle messages from content scripts manage the logger state
+        if (request?.type === 'content_script_ready') {
+            if (sender.tab?.id !== undefined) {
+                activeContentTabs.add(sender.tab.id);
+                if (!loEventActive) {
+                    startLogger();
+                }
+            }
+            return;
+        } else if (request?.type === 'content_script_unloading') {
+            if (sender.tab?.id !== undefined) {
+                activeContentTabs.delete(sender.tab.id);
+                if (activeContentTabs.size === 0) {
+                    stopLogger();
+                }
+            }
+            return;
+        }
+        // Forward analytics events only when the logger is active
+        if (!loEventActive) {
+            return;
+        }
         request['wa_source'] = 'client_page';
         loEvent.logEvent(request['event'], request);
     }
@@ -142,55 +181,59 @@ chrome.webRequest.onBeforeRequest.addListener(
       especially new pages. They do inject a lot of noise, though, and
       from there, being able to easily ignore these is nice.
      */
-    function(request) {
+    function (request) {
+        // No logger availaber
+        if (!loEventActive) {
+            return;
+        }
         //chrome.extension.getBackgroundPage().console.log("Web request url:"+request.url);
         var formdata = {};
         let event;
-        if(request.requestBody) {
+        if (request.requestBody) {
             formdata = request.requestBody.formData;
         }
-        if(!formdata) {
+        if (!formdata) {
             formdata = {};
         }
-        if(RAW_DEBUG) {
+        if (RAW_DEBUG) {
             loEvent.logEvent('raw_http_request', {
-                'url':  request.url,
+                'url': request.url,
                 'form_data': formdata
             });
         }
 
-        if(this_a_google_docs_save(request)){
+        if (this_a_google_docs_save(request)) {
             //chrome.extension.getBackgroundPage().console.log("Google Docs bundles "+request.url);
             try {
                 /* We should think through which time stamps we should log. These are all subtly
                   different: browser event versus request timestamp, as well as user time zone
                   versus GMT. */
                 event = {
-                    'doc_id':  googledocs_id_from_url(request.url),
+                    'doc_id': googledocs_id_from_url(request.url),
                     'url': request.url,
                     'bundles': JSON.parse(formdata.bundles),
                     'rev': formdata.rev,
                     'timestamp': parseInt(request.timeStamp, 10)
                 };
                 logFromServiceWorker(event);
                 loEvent.logEvent('google_docs_save', event);
-            } catch(err) {
+            } catch (err) {
                 /*
                   Oddball events, like text selections.
                 */
                 event = {
-                    'doc_id':  googledocs_id_from_url(request.url),
+                    'doc_id': googledocs_id_from_url(request.url),
                     'url': request.url,
                     'formdata': formdata,
                     'rev': formdata.rev,
                     'timestamp': parseInt(request.timeStamp, 10)
                 };
                 loEvent.logEvent('google_docs_save_extra', event);
             }
-        } else if(this_a_google_docs_bind(request)) {
+        } else if (this_a_google_docs_bind(request)) {
             logFromServiceWorker(request);
         } else {
-            logFromServiceWorker("Not a save or bind: "+request.url);
+            logFromServiceWorker("Not a save or bind: " + request.url);
         }
     },
     { urls: ["*://docs.google.com/*"] },
@@ -202,10 +245,10 @@ chrome.webRequest.onBeforeRequest.addListener(
 chrome.runtime.onInstalled.addListener(reinjectContentScripts);
 async function reinjectContentScripts() {
     for (const contentScript of chrome.runtime.getManifest().content_scripts) {
-        for (const tab of await chrome.tabs.query({url: contentScript.matches})) {
+        for (const tab of await chrome.tabs.query({ url: contentScript.matches })) {
             // re-inject content script
             await chrome.scripting.executeScript({
-                target: {tabId: tab.id, allFrames: true},
+                target: { tabId: tab.id, allFrames: true },
                 files: contentScript.js,
             }, function () {
                 if (!chrome.runtime.lastError) {
@@ -215,10 +258,3 @@ async function reinjectContentScripts() {
         }
     }
 }
-
-// Let the server know we've loaded.
-loEvent.logEvent("extension_loaded", {});
-
-// And let the console know we've loaded
-// chrome.extension.getBackgroundPage().console.log("Loaded"); remove
-logFromServiceWorker("Loaded");

extension/writing-process/src/manifest.json

@@ -17,7 +17,8 @@
         "storage",
         "nativeMessaging",
         "scripting",
-        "activeTab"
+        "activeTab",
+        "tabs"
     ],
     "icons": {
 	    "48": "assets/lousy-fountain-pen-48.png"

extension/writing-process/src/writing.js

@@ -10,6 +10,19 @@ import { googledocs_id_from_url, treeget } from './writing_common';
    General Utility Functions
 */
 
+// Notify the service worker that this content script is active. We also
+// provide a hook to let the service worker know when the script is about to
+// unload so it can perform any necessary cleanup (for example, shutting down
+// loggers when no tabs are active).
+if (chrome.runtime?.id !== undefined) {
+    chrome.runtime.sendMessage({ type: 'content_script_ready' });
+    window.addEventListener('beforeunload', () => {
+        if (chrome.runtime?.id !== undefined) {
+            chrome.runtime.sendMessage({ type: 'content_script_unloading' });
+        }
+    });
+}
+
 function log_error(error_string) {
     /*
        We should send errors to the server, but for now, we

learning_observer/VERSION

@@ -1 +1 @@
-0.1.0+2025.08.07T20.03.33.270Z.c17a54d7.berickson.202507.new.lti.updates
+0.1.0+2025.09.15T18.58.19.025Z.cb6381ff.berickson.202509.extension.fixes

learning_observer/learning_observer/incoming_student_event.py

@@ -187,6 +187,14 @@ async def handle_incoming_client_event(metadata):
     # The adapter allows us to handle old event formats
     adapter = learning_observer.adapters.adapter.EventAdapter()
 
+    handler_log_closed = False
+
+    def close_handler_log():
+        nonlocal handler_log_closed
+        if not handler_log_closed:
+            log_event.close_logfile(filename)
+            handler_log_closed = True
+
     async def handler(request, client_event):
         '''
         This is the handler for incoming client events.
@@ -206,11 +214,16 @@ async def handler(request, client_event):
         log_event.log_event(
             json.dumps(event, sort_keys=True),
             filename, preencoded=True, timestamp=True)
+        if client_event.get("event") == "terminate":
+            debug_log("Terminate event received; closing handler log file")
+            close_handler_log()
+            return []
         await pipeline(event)
 
     # when the handler garbage collected (no more events are being passed through),
     # close the log file associated with this connection
-    weakref.finalize(handler, log_event.close_logfile, filename)
+    weakref.finalize(handler, close_handler_log)
+    handler.close = close_handler_log
 
     return handler
 
@@ -291,20 +304,32 @@ def decode_and_log_event(msg):
     )
     COUNT += 1
 
+    decoder_log_closed = False
+
+    def close_decoder_logfile():
+        nonlocal decoder_log_closed
+        if not decoder_log_closed:
+            log_event.close_logfile(filename)
+            decoder_log_closed = True
+
     async def decode_and_log_event(events):
         '''
         Take an aiohttp web sockets message, log it, and return
         a clean event.
         '''
-        async for msg in events:
-            if isinstance(msg, dict):
-                json_event = msg
-            else:
-                json_event = json.loads(msg.data)
-            log_event.log_event(json_event, filename=filename)
-            yield json_event
-        # done processing events, can close logfile now
-        log_event.close_logfile(filename)
+        try:
+            async for msg in events:
+                if isinstance(msg, dict):
+                    json_event = msg
+                else:
+                    json_event = json.loads(msg.data)
+                log_event.log_event(json_event, filename=filename)
+                yield json_event
+        finally:
+            # done processing events, can close logfile now
+            close_decoder_logfile()
+
+    decode_and_log_event.close = close_decoder_logfile
     return decode_and_log_event
 
 
@@ -434,6 +459,21 @@ async def decode_lock_fields(events):
                 event.update(lock_fields)
                 yield event
 
+    async def handle_terminate_events(events):
+        '''Stop processing when a terminate event is received.'''
+        async for event in events:
+            if event.get('event') == 'terminate':
+                debug_log('Terminate event received; shutting down connection and cleaning up logs.')
+                handler_close = getattr(event_handler, 'close', None)
+                if callable(handler_close):
+                    handler_close()
+                decoder_close = getattr(decoder_and_logger, 'close', None)
+                if callable(decoder_close):
+                    decoder_close()
+                await ws.close()
+                return
+            yield event
+
     async def filter_blacklist_events(events):
         '''This function stops the event pipeline if sources
         should be blocked.
@@ -498,6 +538,7 @@ async def process_ws_message_through_pipeline():
         events = process_message_from_ws()
         events = decoder_and_logger(events)
         events = decode_lock_fields(events)
+        events = handle_terminate_events(events)
         events = handle_auth_events(events)
         events = filter_blacklist_events(events)
         events = process_blob_storage_events(events)