A recent user shared an effective method to troubleshoot and resolve device registration failures detected via the Device Registration Failure Tracking Dashboard in ControlUp. The issue typically manifests when endpoints fail to register correctly, possibly due to mismatched or outdated registration codes that prevent successful detection and installation of necessary software components.
The solution revolves around a PowerShell script (PS1) used within an Intune Script and Remediation framework paired with a Win32 application deployment set as a required install. This script checks if the device's registration code matches the expected value—defined by modifying a single variable ($ExpectedRegCode) in the script. If the detected registration code does not match, the script initiates an uninstall command to remove existing components causing conflicts. It subsequently restarts the Intune Management Extension service to trigger a forced synchronization and installation of the latest published application version. This approach ensures that devices automatically correct registration code discrepancies by clearing stale state and obtaining the correct app package and registration anew.
This method leverages ControlUp’s Device Registration Failure Tracking Dashboard to pinpoint affected endpoints quickly, making remediation targeted and efficient. It is particularly useful in environments managed by Microsoft Intune, where automated script remediation helps maintain compliance and consistency of Win32 app deployments tied to device registration status.
Administrators planning to apply this solution should customize the $ExpectedRegCode variable within the script to reflect their environment’s correct registration string. The process assumes familiarity with Intune’s Script and Remediation capabilities and Win32 app deployment mechanics. ControlUp documentation and Microsoft’s official Intune script remediation guides provide valuable context for further customization and expansion of this workflow.
Read the entire article here...
Scripts Related Training & Support Archives
Scripts training and support-related archives from inside the ControlUp Community on Slack.
How to Refresh Service and Application Data On-Demand in ControlUp
A common challenge faced by ControlUp users involves timely updating of endpoint data, especially when tracking specific services or applications. In one case, a user wanted to confirm the removal of a service on endpoints but found that ControlUp still reported the service as running despite manual removal. This discrepancy occurs because the ControlUp agent updates different types of metrics at varied intervals. Core system metrics typically refresh every 60 seconds, but certain metrics such as service status and installed applications are updated less frequently—services refresh hourly (and shortly after a system reboot), while installed applications update only once per day.
This update schedule means that relying solely on on-demand refresh within ControlUp for some metrics is limited, as there is no built-in immediate refresh capability for services or installed apps. To overcome this, users can create a Custom Action script to gather the needed data on-demand. By scripting, users can query the current service status or application state directly from the endpoints and write the results to a custom data index in ControlUp. This approach provides a precise and immediate reflection of endpoint conditions without waiting for the default agent update cycle.
ControlUp’s scripting capabilities are documented in detail in the official scripting guide, available at https://support.controlup.com/docs/scripting-guide. This guide helps users build custom scripts that integrate into ControlUp workflows, enabling on-demand data collection tailored to specific monitoring or troubleshooting needs.
As of now, no direct feature exists within ControlUp to force an on-demand refresh of hourly or daily metrics such as service and installed app status, but leveraging Custom Action scripts offers an effective workaround. Users looking to improve real-time monitoring of endpoint services should consider implementing these custom scripted solutions until such features potentially appear on future ControlUp development roadmaps.
Read the entire article here...
Read the entire article here...
Handling Script Failures and Output in ControlUp Workflows: Error Ignoring, Conditional Logic, and Feature Updates
In a ControlUp workflow, users may want to handle script failures gracefully, akin to a "try-catch" mechanism seen in traditional programming. A user inquired about running an alternative action when a script run on a device fails. Currently, if the script fails, the workflow ends with an error, and no subsequent action is triggered automatically. The recommended approach is to use the "Ignore Error" option on the "Run Script" node, which prevents the workflow from stopping on error. Afterward, an "If Else" node can be added to check the status of the "Run Script" node and conditionally execute alternative actions based on success or failure. This method enables branching logic without halting the workflow.
A related challenge encountered was handling multiline output messages from scripts. The native ControlUp environment does not currently support converting multiline output into a single line with or without explicit newline characters such as "\n". The ControlUp team acknowledged this need and plans to introduce this string transformation functionality soon, with expectations for release within a week. While this feature is pending, custom scripting or intermediate handling outside ControlUp might be required to process multiline outputs.
Users also raised the idea of more advanced scripting capabilities within workflows, such as embedding secure, sandboxed JavaScript actions or subflows callable like functions. The team confirmed interest in this concept but noted that it is not currently on the immediate roadmap and will require future prioritization.
Finally, a limitation was noted: timeout errors from script execution (defaulting to 60 minutes) cannot be ignored by the "Ignore Error" setting; when a script times out, the workflow fails by design. The ControlUp team is investigating possible improvements to how timeouts are handled in workflows.
For now, users can implement error handling in workflows using the "Ignore Error" flag combined with conditional checks but should be aware of limitations around timeout errors and multiline output processing. Updates and added features are in development to enhance workflow flexibility and scripting capabilities. For more details on creating and managing workflows, users can visit the official ControlUp documentation at https://docs.controlup.com or the ControlUp Academy at https://cuacademy.controlup.com.
Read the entire article here...
Read the entire article here...
How to Ensure ControlUp Compliance Scripts Correctly Return and Respect Exit Codes to Avoid False Positives
In ControlUp, when executing scripts for Compliance monitoring, it is crucial that the system correctly recognizes and respects the exit codes of these scripts to avoid false positive or false negative compliance reports. One common issue reported involves ControlUp failing to honor the exit codes returned by compliance scripts, which can lead to inaccurate compliance status being displayed.
To address this, users should ensure that their compliance scripts are properly configured and that ControlUp is set up to interpret script exit codes correctly. ControlUp's official guidance on integrating scripts for compliance purposes includes instructions on how to add scripts correctly and manage their execution and return values. This documentation explains how ControlUp evaluates the success or failure of compliance scripts based on the exit codes, and how improper scripting or configuration can cause misinterpretation of compliance results.
The primary resource for resolving issues related to script exit code recognition in ControlUp Compliance is the official support article available at: https://support.controlup.com/docs/how-to-add-scripts-to-controlup-for-compliance. This article provides explicit steps and examples for adding scripts into ControlUp for compliance checks, including how scripts should signal their outcomes through exit codes, which in turn informs the compliance reporting mechanism.
Users experiencing false positive compliance alerts should verify that their scripts are designed to return proper exit codes — typically, an exit code of zero indicates success (compliant state), whereas any non-zero exit code indicates failure (non-compliant state). Correctly following the official scripting guidelines and ensuring scripts adhere to these conventions will help ControlUp generate accurate compliance reports without the issue of false positives due to unrecognized or improperly handled exit codes.
Read the entire article here...
Read the entire article here...
Efficiently Combining and Processing Large Index Datasets in ControlUp Workflows Without Native Loop Constructs
A community member faced challenges building a workflow in ControlUp to combine two indexes dynamically for a nightly dashboard summarizing the previous day’s environment status. The primary difficulties arose from limitations in the workflow engine compared to PowerShell scripting, particularly related to looping constructs, array size management, and efficient data handling. Attempting to accumulate all data into a single large array caused performance degradation, and efforts to split data handling into groups of 100 records ran into issues because workflows lacked a traditional for-loop or the ability to reinitialize variables inside loops.
ControlUp experts clarified that appending to arrays in loops is generally inexpensive, but performance issues often stem from JSON modification or calculation nodes that operate on the entire array each iteration. Instead of keeping large arrays in memory, a recommended pattern is to flip the subflow logic: allow the subflow to write records directly to the target custom index and return no data to the main flow. The main flow can paginate data requests using Get Custom Data (which supports paging via from/size parameters), looping over pages where each subflow processes one page end-to-end, avoiding large in-memory arrays and reinitialization challenges.
To emulate traditional loop behavior, a “fake while loop” workaround was suggested by creating a dummy array representing the number of iterations desired (e.g., 20), then looping over that array. Combined with OpenSearch’s partitioning (`include > partitions` and `include > num_partitions`), this approach divides large datasets into manageable buckets processed in separate iterations. The configuration can be sized to match the environment—for example, capturing 4,000 records per iteration across 20 iterations to cover up to 80,000 results, adjustable as needed.
A practical example from the discussion involved combining device data from two ControlUp indexes: one filtering Windows devices by specific event logs, and the other fetching device information filtered by the extracted device IDs. Merging these on the device ID with the "Preserve structure from: both" option enabled results in a unified dataset ready for further processing or custom indexing. This workflow ran efficiently in about four seconds on test data. To control data volume, filtering steps were added to isolate devices exhibiting significant event counts (e.g., more than 5 events in 24 hours), which reduced processing load while focusing on impactful network issues.
The conversation highlighted the current lack of a native "for" loop feature in ControlUp workflows, but noted this capability is planned for future releases. Meanwhile, users can leverage paging, subflows writing directly to indexes, and OpenSearch partitions to manage large datasets effectively. Per-iteration writes to custom indexes are feasible if API rate limits and retry logic are properly handled. For large data reads, Get Custom Data is preferred over Get Data Index because of its paging capabilities. These insights provide a reliable framework for users needing to aggregate and analyze dynamic multi-index data in ControlUp workflows while balancing performance and complexity.
For additional guidance on ControlUp workflow nodes and custom data handling, refer to ControlUp’s official knowledge-base and documentation at https://docs.controlup.com and https://cuacademy.controlup.com.
Read the entire article here...
Read the entire article here...
Managing FSLogix Profile Size: Best Practices with ControlUp Monitoring and Profile Cleanup Automation
A community member transitioning from eG Enterprise to ControlUp in a virtual desktop infrastructure (VDI) or remote desktop services (RDS) environment inquired about managing FSLogix profile size through logon or logoff scripts executed by ControlUp. The goal was to reduce profile bloat by deleting specific files within user profiles during session start or end. It was clarified that ControlUp does not support traditional logon or logoff scripts in the classical sense, although it can trigger scripts on events such as "User logged On." This functionality, however, is not ideally suited for the described profile cleanup use case.
Regarding FSLogix profile management, the conversation highlighted that VHD disk compaction is enabled by default in recent FSLogix releases, which automatically helps reduce profile size. However, disk compaction alone may not be sufficient. A practical approach mentioned involved setting up ControlUp alerts to monitor profile conditions—such as low disk space—triggering notifications through ServiceNow tickets for manual intervention by the VDI team. Although automation was still a work in progress, this method added a layer of proactive management.
Another critical recommendation was the use of the FSLogix redirections.xml configuration file. This file allows administrators to exclude certain paths or folders within the user profile—such as temporary files or application cache—from being saved. By strategically excluding these locations, profile bloat can be effectively reduced before it accumulates. The official Microsoft documentation on VHD Disk Compaction (https://learn.microsoft.com/en-us/fslogix/concepts-vhd-disk-compaction) and the redirections.xml configuration (https://learn.microsoft.com/en-us/fslogix/concepts-redirections-xml) provide authoritative guidance on these techniques.
For scripted profile cleanup during user logoff, the community recommended leveraging traditional Group Policy Object (GPO) or Citrix Workspace Environment Management (WEM) tools. One valuable resource shared was Aaron Parker’s Profile Cleanup script (https://stealthpuppy.com/fslogix/profilecleanup/), which is widely used for automating the removal of unwanted files in FSLogix profiles.
In summary, while ControlUp offers monitoring and alerting capabilities that can assist in managing FSLogix profile size, tasks like cleaning profile contents on logon or logoff are better handled by existing scripting mechanisms triggered outside of ControlUp, such as GPO or WEM. Employing FSLogix’s built-in disk compaction and profile exclusion features forms the foundation of efficient profile size management complemented by monitoring workflows for remediation alerts.
Read the entire article here...
Read the entire article here...
ControlUp v9.2.5.776 REST API Bug Affects Horizon 2406 and 2412 Integration; Workaround and Fix Pending
In ControlUp version 9.2.5.776, a significant issue was identified impacting Omnissa Horizon environments running versions 2412 and 2406. This release introduced a bug affecting the REST API integration used by these Horizon versions, causing disruptions in built-in SYNC functionality and monitoring, including problems with the new Unified Access Gateway (UAG) agentless monitor. The root cause lies in the incompatibility or improper support of REST API versions 3 and 4 by this ControlUp release. Horizon environments 2503 and above, which utilize REST API version 5, were not affected and continued to function correctly.
As a temporary workaround, users in affected Horizon 2412 and 2406 environments can revert their Collectors to use the older SOAP-based method by setting a new registry entry (Use Soap = 1). This older SOAP method, while more resource-intensive and anticipated to be phased out eventually, restores functionality until the bug is fixed. ControlUp has clarified that this is a bug rather than a planned deprecation of REST API support for these Horizon versions, and a fix is actively being developed and will be released promptly.
The issue was initially not reflected in the release notes or documentation, which generally specify Horizon version requirements starting at 2406 or higher for Omnissa Horizon integration. Users should be aware that Omnissa Horizon 8.2412 remains supported until January 28, 2028, underlining the importance of maintaining compatibility. ControlUp's development team is replicating the problem using different 2412 builds to understand the issue fully, noting that the bug seems reproducible with specific builds like 8.14.0 (build 14371628935).
Caution is encouraged for organizations running Horizon 2412 or 2406 environments on this ControlUp version to avoid unanticipated monitoring data loss, as was experienced in some community reports with prolonged missing metrics. ControlUp’s documentation team is preparing to add this issue as a known bug in the current release notes to inform users more effectively until a correction is deployed. For the most accurate and updated guidance, users should consult ControlUp’s official resources at https://docs.controlup.com and seek support if needed.
Read the entire article here...
Read the entire article here...
How to Identify Java Process Executable Paths on VDIs Using ControlUp Real-Time Data and Recurring Exports
A common challenge among IT teams managing virtual desktop infrastructure (VDI) environments is identifying the exact executable paths of Java processes running on their VDI machines. In a recent inquiry, a ControlUp user sought to locate Java processes and determine the full execution path of these processes on their VDIs using ControlUp dashboards. Although they were able to create a dashboard widget that revealed the folder structure, they found no direct way to report the full executable path for historical data within ControlUp.
The root cause identified is that ControlUp does not retain the full executable path information as part of its historical data records. Instead, this level of process detail—specifically the executable path—is only available in live, real-time data monitoring. For those needing to track Java process paths over time, this limitation means historical analysis of full executable paths is not natively supported by ControlUp’s historical data collection.
Several users acknowledged that having the executable path data visible and reportable in a historical context would be highly valuable, especially for use cases such as identifying outdated Java runtime versions and understanding diverse Java process usage patterns across an organization’s VDI environment. While real-time data is sufficient for immediate troubleshooting, historical visibility would enhance trend analysis and proactive software management.
As a practical workaround, it was suggested to leverage ControlUp’s live monitoring capabilities combined with recurring data exports using the ControlUp PowerShell module command `Export-CuQuery`. By regularly exporting live process data—including executable paths—over time, teams can build their own longitudinal datasets outside of ControlUp. This approach allows filtering and analysis of Java process paths beyond what the platform currently stores in its historical database.
Regarding the broader context of Java monitoring integration into ControlUp for Azure Virtual Desktop (CU4A), current support remains focused on real-time visibility, with no confirmed release date for extending these capabilities to historical data or enhanced Java-specific monitoring features. Users are encouraged to stay updated through official ControlUp resources.
For further details on ControlUp capabilities, data export options, and dashboard customization, users may consult the ControlUp Knowledge Base at https://docs.controlup.com and the ControlUp Academy at https://cuacademy.controlup.com.
Read the entire article here...
Read the entire article here...
Automating Device Group Assignment in ControlUp Workflows Using Registry Key Data
A community member inquired about automating device group assignment in ControlUp based on a specific registry key value. The initial approach discussed involved writing a PowerShell script to read the registry key and create a custom index in ControlUp, which could then feed into a workflow for moving devices to the appropriate device group. This method also opened possibilities for using the data in dashboards, creating alerts for registry changes, and triggering remediation workflows.
A practical PowerShell script example was shared to demonstrate how to write, read, and output a registry key value under the current user (HKCU). This script was integrated with ControlUp’s Device Events by printing the output between defined event markers. Subsequently, a more detailed script was contributed, which collects registry information along with system and timestamp metadata, outputs it as a compressed JSON object, and supports error handling if the registry key access fails. This script is intended to run periodically to populate ControlUp’s data index, providing the basis for alerting and workflow triggers.
The recommended implementation steps include adding the script to the environment to gather registry data regularly, setting up alerts to trigger on specific registry values, and using ControlUp workflows with webhooks to move devices to the correct device groups based on the registry data. While alerts were initially used for this purpose, the community acknowledged the drawback of proliferation—needing many alerts for multiple groups—and expressed a preference to rely more on workflows for automation, preserving alerts for genuine issues.
To advance beyond alerts, the suggestion was made to leverage ControlUp’s API to retrieve custom data directly, enabling workflows to act on this real-time data without spawning numerous alerts. This approach supports scalable device management workflows, automating group assignments effectively. A recommendation was offered to engage ControlUp Customer Success Management (CSM) or Professional Services for further assistance with complex workflow setups integrating API data extraction. The discussion underscores the evolving use of ControlUp’s scripting, alerting, and workflow capabilities to streamline device group management based on registry key states.
For further reference, ControlUp’s official documentation on custom data scripting, workflows, and alerts can be found at https://docs.controlup.com, and detailed learning modules are available via ControlUp Academy at https://cuacademy.controlup.com.
Read the entire article here...
Read the entire article here...
Troubleshooting Missing macOS Script Details in ControlUp Event Logs and Resolution via 2.18 RC Agent
Users managing macOS devices within ControlUp reported an issue where script execution events only displayed "script started" and "script completed" messages without showing which script was run or its output. This behavior was a departure from prior functionality, where script details and outputs were visible. Windows devices did not exhibit this problem, and macOS scripts continued to generate output as expected. The concern arose when verifying the actual execution of scripts on macOS devices became necessary, but the ControlUp console failed to surface detailed script information.
Further investigation revealed that ControlUp versions 2.17 and 2.18 for macOS, as well as the Windows version, should include script details in raw event data accessible either through developer browser tools or the ControlUp API endpoint at https://api.controlup.io/reference/get-system-events. However, in the normal device view within ControlUp, the description field showing script details was missing or blank, even though the event index properly contained the script output information. This suggested a user interface issue rather than a complete loss of the event data.
The root cause appeared to be tied to the macOS 2.18 release state. The 2.18 build available was a special release candidate (RC) version, not yet generally available (GA), and it contained fixes targeting this exact problem. Users running this 2.18 RC version (including builds like 2.18.301.5B9E7EB35 and RC9) reported that the issue was resolved in those builds, with script details properly displayed alongside event logs. ControlUp staff offered to enable this release candidate on affected tenants to restore full visibility of macOS script execution events.
In summary, the lack of script detail visibility on macOS devices in ControlUp event views was a recognized bug in releases prior to 2.18. The problem was fixed in the 2.18 RC macOS agent builds, which restored proper logging and display of script names and outputs. Users encountering this should verify their macOS agent version and upgrade to the 2.18 RC or later when it becomes generally available. Meanwhile, script event data can still be queried directly via the ControlUp API or found in event indices, offering a workaround until the UI fully reflects the script details. For more information on monitoring system events and interacting with the ControlUp API, consult the official documentation at https://docs.controlup.com/ and https://api.controlup.io/reference/get-system-events.
Read the entire article here...
Read the entire article here...
