Monitoring component
Agent for file monitoring
File retrieval and download
Request originals from Engines
Outlier detection
Spot abnormal file behavior
Deployment and configuration
Install and configure monitoring
Overview
GermainUX collects, parses, analyzes, correlates, archives, and searches application, system, infrastructure, and business files. The GermainUX Engine monitors approved file locations, detects new or changed files, applies the appropriate parser, and converts relevant content into structured GermainUX events, metrics, or transactions for real-time or scheduled analysis.Monitoring component
Supported sources
GermainUX can monitor files available through approved sources such as:- Local directories accessible to the Engine.
- Network-mounted or shared directories.
- Application and server log directories.
- Files made available through an approved remote-transfer process.
- Container or orchestrator log locations.
- Generated reports and extracts.
- Exported application, database, or integration files.
- Compressed archives containing supported files.
rsync.
The exact source method depends on the operating system, network architecture, credentials, and GermainUX component configuration.
Supported file formats
GermainUX supports text and structured formats such as:- Plain text.
- Application and system logs.
- JSON.
- CSV and other delimited data.
- XML.
- Fixed-width records.
Show all 9
Show all 9
- Compressed archives such as ZIP.
- Application-specific exports.
- Binary formats for which a compatible GermainUX parser is available.
Capabilities
File discovery
GermainUX can monitor a configured directory for:- New files.
- Changed files.
- Existing files at initial deployment.
- Empty files.
- Files in subdirectories.
- Files matching approved names or patterns.
- Application-specific file types.
- File creation and modification activity.
Near-real-time or scheduled collection
Collection frequency is configurable. Use:- Short polling intervals when rapid detection is required.
- Longer intervals for large directories or lower-priority files.
- Scheduled collection for reports, exports, or batch-generated files.
- Event-driven mechanisms when supported by the source and component.
Parsing and normalization
GermainUX parsers convert file content into structured data that can be searched, compared, categorized, and correlated. Parsing can extract:- Timestamp.
- Severity.
- Application.
- Component.
- Host.
- Process or thread.
Show all 13
Show all 13
- User or session identifier.
- Transaction or correlation identifier.
- Error code.
- Message.
- Duration.
- Numeric measurements.
- Application-specific attributes.
Preconfigured parsers
GermainUX includes parsers for supported applications, infrastructure technologies, and common formats. Preconfigured parsers should be used where available because they already define relevant:- Record boundaries.
- Timestamp extraction.
- Severity.
- Error and event fields.
- Application metadata.
- Multiline handling.
- Event or transaction generation.
Custom parsing rules
Use GermainUX Rules when a custom file format or application message must be parsed. Custom rules can:- Identify record boundaries.
- Extract fields.
- Convert values.
- Create events, metrics, or transactions.
- Categorize errors.
- Exclude irrelevant records.
- Add application or environment context.
- Correlate related records.
Log monitoring
GermainUX can monitor logs generated by:- Applications.
- Web and application servers.
- Databases.
- Operating systems.
- Containers.
- Integration platforms.
Show all 11
Show all 11
- APIs and services.
- Authentication systems.
- CRM and ERP applications.
- eCommerce applications.
- Custom software.
- Errors.
- Exceptions.
- Warnings.
- Availability events.
- Authentication failures.
- Integration failures.
Show all 11
Show all 11
- Performance degradation.
- Configuration problems.
- Crashes and restart activity.
- Newly observed or recurring messages.
- Application-specific business failures.
Error categorization
GermainUX can categorize parsed errors and messages to:- Group equivalent errors whose dynamic values differ.
- Distinguish newly observed problems from known recurring problems.
- Count affected applications, users, or transactions.
- Track recurrence and trends.
- Prioritize conditions by frequency and impact.
- Reduce duplicate investigation.
Correlation and tracing
GermainUX can correlate information extracted from files with other monitored data when common identifiers or context are available. Correlation can use:- Timestamp.
- Application.
- Host or server.
- Process or thread.
- User.
- Session ID.
Show all 11
Show all 11
- Transaction ID.
- Request ID.
- Correlation ID.
- Error code.
- Business identifier.
- Browser user sessions.
- Session Replay.
- Network requests.
- Application transactions.
- Code profiling.
- Database activity.
Show all 9
Show all 9
- Infrastructure metrics.
- Business processes.
- Other files and logs.
Search and investigation
Parsed data can be searched and filtered using the fields extracted by the applicable parser. Teams can search by:- Application or component.
- Host.
- Time range.
- Severity.
- Error or message.
- User or session.
Show all 11
Show all 11
- Transaction or correlation identifier.
- File name.
- Parser.
- Category.
- Application-specific attributes.
File retrieval and download
Authorized GermainUX administrators can request an original file when it remains available to the Engine. A typical retrieval workflow is:- Open the relevant file or parsed event in GermainUX.
- Select the file-download request.
- The GermainUX Engine retrieves and uploads the requested file.
- GermainUX notifies the authorized requester when the file is available.
- The requester downloads it through the provided secured link or GermainUX interface.
- The original file still being available.
- The Engine retaining read access.
- File size and transfer limits.
- Network connectivity.
- GermainUX storage and retention configuration.
- User authorization.
Document audit
GermainUX can audit supported files and documents for changes or application-specific conditions. Document Audit can be used to:- Detect the creation or modification of a file.
- Compare supported document content.
- Identify expected or unexpected values.
- Track processing status.
- Validate generated reports or exports.
- Detect missing or incomplete information.
File archiving
GermainUX can archive files according to approved operational requirements. Archiving can help:- Preserve files required for investigation.
- Move processed files from an active directory.
- Reduce accumulation in application directories.
- Retain evidence for an approved period.
- Separate successfully processed files from failures.
File purging
GermainUX can automatically purge eligible files according to configured rules and retention periods. See Automatic File Purging. Before enabling purging:- Confirm the exact directory.
- Define file patterns and minimum age.
- Exclude active and required files.
- Verify legal and operational retention requirements.
- Test the rule in a non-production directory.
- Confirm that files are archived or backed up when required.
- Use a dedicated account with access limited to the intended directory.
Automatic log-level control
GermainUX can use approved automation to change an application’s logging level when additional diagnostics are required, then restore the previous level. See Automatic Log-Level Control. A safe workflow should:1
Detect a qualifying issue
2
Validate that log-level automation is authorized
3
Increase logging for the affected component
4
Collect diagnostics for a limited period
5
Restore the original logging level
6
Confirm that disk and application performance remain acceptable
Business benefits
File and Log Monitoring helps organizations:- Detect application and infrastructure failures automatically.
- Identify new and recurring errors.
- Reduce the time required to find relevant log evidence.
- Correlate technical failures with affected users and business processes.
- Standardize evidence from different applications and formats.
- Measure the frequency and impact of an issue.
Show all 10
Show all 10
- Preserve diagnostic files for investigation.
- Automate retention and cleanup.
- Trigger approved notifications, diagnostics, and corrective workflows.
- Reduce the need to access production servers manually.
Analytics
GermainUX can analyze parsed file data through KPIs, measures, pivots, trends, drill-through views, correlation, and outlier detection.
Custom KPIs can be created from any parsed value that can be represented as a GermainUX event, metric, or transaction.
Outlier detection
GermainUX can identify abnormal file or log behavior such as:- A sudden increase in error volume.
- A newly observed message.
- Missing expected files.
- Delayed file arrival.
- Unusually large or small files.
- Abnormal processing duration.
Show all 9
Show all 9
- An unexpected change in record volume.
- A component producing significantly more errors than comparable components.
- A recurring failure that exceeds its established baseline.
Notifications and automation
GermainUX users can create Watches to receive notifications when existing file or log insights meet conditions of interest. Detected conditions can trigger approved actions such as:- Email or other configured notifications.
- Reports.
- HTTP requests or webhooks.
- Incident-management integrations.
- Diagnostic scripts.
- Local programs.
Show all 11
Show all 11
- SQL queries.
- File retrieval.
- Archiving or purging.
- Temporary log-level changes.
- Approved corrective workflows.
Collection architecture
A typical File and Log Monitoring flow is:1
The application or system creates a file
2
The GermainUX Engine detects it through a Directory Monitor or another configured source
3
The Engine reads or securely retrieves the file
4
The applicable parser extracts and normalizes relevant records
5
GermainUX generates events, metrics, or transactions
6
Analytics categorizes, correlates, and evaluates the data
7
Watches or approved actions respond to qualifying conditions
8
The original file is retained, archived, or purged according to policy
Prerequisites
Before deployment, confirm:- A GermainUX Engine is installed and running.
- The Engine can reach the file source.
- A dedicated account has the required read access.
- Write or delete access is granted only when archiving or purging requires it.
- The file format and encoding are known.
- File-creation, rotation, and compression behavior is understood.
Show all 11
Show all 11
- A compatible parser is available.
- The application, server, and environment metadata are defined.
- Monitoring frequency and expected volume are known.
- Retention and privacy requirements are approved.
- Very large, binary, or compressed files have been tested.
Configuration
Add the monitored server
1
Open Germain Workspace
2
Create or select the server containing the files
3
Configure the operating system and network information
4
Add approved credentials when remote access is required
5
Validate connectivity from the GermainUX Engine
Create a Directory Monitor
1
Go to Germain Workspace > Wizards > Directory Monitor
2
Select the monitoring node
3
Select the GermainUX Engine
4
Select the monitored server
5
Enter the exact directory path
6
Select the appropriate Directory Monitor component type
7
Define filename or file-pattern filters
8
Choose whether to monitor subdirectories
9
Choose whether to process existing files
10
Choose whether to process empty files
11
Configure polling or event-based behavior where available
12
Set the collection interval
13
Select the applicable parser
14
Associate the monitor with the application and environment
15
Review and finish the wizard
Configure a parser
1
Identify whether a preconfigured parser already exists
2
Collect representative sample files
3
Define file encoding and record boundaries
4
Define timestamp, severity, message, and metadata extraction
5
Handle multiline records
6
Configure events, metrics, or transactions
7
Add categorization and exclusions
8
Test valid, malformed, partial, rotated, and compressed files
9
Confirm that sensitive values are not unnecessarily stored
10
Deploy the parser to the applicable Directory Monitor
Configure remote collection
For remote files:1
Use an approved secure protocol or transfer process
2
Create a dedicated least-privilege account
3
Restrict access to the required source directories
4
Protect credentials or SSH keys
5
Define whether files are read remotely or copied to a staging directory
6
Prevent duplicate processing
7
Define retry and partial-transfer behavior
8
Confirm how source-file rotation and deletion are handled
9
Secure and clean the staging directory according to policy
10
Validate connectivity and performance
File rotation and partial files
Applications may rotate or continue writing to files while monitoring is active. Configure and test behavior for:- Renamed files.
- Timestamped files.
- Size-based rotation.
- Compressed rotated files.
- Files copied while still being written.
- Duplicate filenames.
Show all 10
Show all 10
- Truncated files.
- Partial transfers.
- Engine restarts.
- Monitoring interruptions.
Privacy and security
Files and logs may contain personal information, credentials, tokens, payment information, health information, source data, or proprietary business content. Before deployment:- Collect only the content required for the monitoring objective.
- Exclude or mask sensitive fields.
- Avoid ingesting passwords, tokens, private keys, or authentication cookies.
- Restrict source-directory and download access.
- Encrypt remote transfers.
- Use least-privilege credentials.
Show all 10
Show all 10
- Protect staging and archive directories.
- Define retention and deletion requirements.
- Audit file retrieval and automated actions.
- Validate custom parsers with representative sensitive-data scenarios.
Validation
After deployment:1
Place or generate a controlled test file
2
Confirm that the Engine detects it
3
Verify that the correct parser is applied
4
Compare extracted fields with the source file
5
Confirm application, server, and environment metadata
6
Test multiline and rotated records
7
Generate a controlled error or threshold condition
8
Verify the expected KPI, Watch, or action
9
Test file retrieval when enabled
10
Test archiving or purging in a non-production directory
11
Confirm that duplicate records are not generated
12
Measure Engine, network, storage, and source-system overhead
Deployment and configuration
- Deploy the GermainUX Engine where it can securely access the required files.
- Create the monitored server, credentials, and exact source directories.
- Deploy a Directory Monitor with the appropriate preconfigured or custom parser.
- Configure secure remote staging when files are not directly accessible to the Engine.
- Configure GermainUX Rules for custom parsing and analysis.
- Configure Categorization for new and recurring conditions.
Show all 14
Show all 14
- Configure Correlation and Tracing across files and other data sources.
- Review Search and Filters.
- Configure Document Audit when supported documents must be validated.
- Configure File Archiving when processed files must be retained or moved.
- Configure Automatic File Purging only after validating the exact scope and retention requirements.
- Configure Automatic Log-Level Control when approved temporary diagnostic logging is required.
- Configure KPIs, SLAs, Watches, reports, and approved actions.
- Validate parsing, privacy, security, retention, and performance before production rollout.
Get Help
Contact GermainUX Support
The Germain Team can help you set this up.
Can't find what you need?
Search all GermainUX docs with Ctrl + K, or use the feedback buttons at the bottom of this page to tell us what is missing.
The content of this document is proprietary to GERMAIN SOFTWARE.