duyanming/Viper

Viper is a .NET-based dashboard and monitoring application built on the Anno microservices framework. It provides system resource monitoring, distributed locking, and user log management, while offering a web interface for service deployment, role-based access control, and cluster status visualization. The system supports multiple database backends and integrates with external notification services like DingTalk.

30 changes.

This period focused on the initialization and expansion of the Viper dashboard project, introducing new plugin services for monitoring, distributed locking, and trace logging. The work involved building out the frontend interface with tabbed navigation and data visualization, while simultaneously updating the underlying Anno framework and database configurations to support these new capabilities.

4 changes.

This period focused on enhancing system observability and operational management by introducing structured logging with trace and user association, alongside a new system log viewing interface. Additionally, the project expanded its frontend capabilities with new Vue components for service analysis, deployment management, and role administration.

A new HelloWorld sample service has been added to the repository. This includes the service's configuration (Anno.config), a ProductDto model, the Program.cs entry point, and batch/shell scripts for starting and stopping the service. The service is configured to register with a local registry at 127.0.0.1:7010, uses port 7012, and leverages the Autofac IoC container with Thrift-based RPC.

Samples/HelloWorldService · high confidence

A new company list page has been added, featuring a search form for company names, a data table displaying company details (code, name, status, address, phone, person, registration date), and pagination controls. The page includes functionality to query the list, change the number of items per page, and toggle the enabled/disabled state of companies (though the state change is currently a placeholder).

Viper/wwwroot/html/company · high confidence

A new distributed lock service plugin has been added to the platform. This feature provides a mechanism for managing distributed locks, including acquiring and releasing locks via API endpoints, with automatic timeout detection and release. The implementation includes a bootstrap configuration, a center for managing lock states, and module endpoints for entering and disposing locks.

Anno.Plugs.DLockService · high confidence

A new member list page has been added at Viper/wwwroot/html/mlist, featuring a search form, a data table displaying user details (account, name, status, company, position, login time, registration time), and action buttons for viewing, resetting passwords, and enabling/disabling accounts. The page uses local static resources (Vue, Element UI, jQuery) rather than CDN links.

Viper/wwwroot/html/mlist · high confidence

Introduces new JavaScript modules for the application's frontend: fconfig.js and func\_roles\_config.js provide a UI for managing functional permissions and role-based access control, allowing administrators to edit, add, and delete functional nodes and assign them to roles. Additionally, welcome.js implements a dashboard with ECharts-based CPU and memory monitoring visualizations, while token.js handles user session and navigation logic. The update also includes the SignalR client library (signalr.min.js) to enable real-time communication capabilities.

Viper/wwwroot/js/scripts · high confidence

Added sample plug-in implementations for 'HelloWorld' and 'SoEasy' services. The HelloWorld plug-in provides a 'SayHello' endpoint that calls the SoEasy service and includes a 'LogSamples' method demonstrating how to associate log entries with a trace context. The SoEasy plug-in provides a 'SayHi' endpoint that returns age-based messages, along with basic arithmetic and product purchase examples.

Samples/Plugs · medium confidence

A new system log (syslog) page has been added, allowing users to view and search system logs by title, content, or trace ID. The interface supports filtering by log type (Info, Warn, Error, Fatal) and includes a link to view detailed trace information for each log entry.

Viper/wwwroot/html/syslog · high confidence

A new static class, AnnoMapper, has been added to Anno.Common. It provides three mapping capabilities: converting a DataTable into a list of strongly-typed objects (Mapper), converting an object into a dictionary of its properties (MapperToDictionary), and mapping properties between two different object types (Mapp). The implementation uses reflection and caching to handle type conversions, including support for enums and generic types.

Anno.Common · high confidence

The ECharts JavaScript library (echarts.min.js) has been added to the Viper/wwwroot/js directory. This enables the application to render interactive charts and graphs within the user interface.

Viper/wwwroot/js · high confidence

A new 'MonitorService' plug-in has been introduced to expose system resource information, specifically CPU and memory usage. This includes a new 'ResourceModule' that provides an API endpoint to retrieve server status, supported by a 'SysWatchUtil' utility class that interfaces with the system's performance monitoring capabilities.

Anno.Plugs.MonitorService · high confidence

Introduced new batch scripts (viperGateWay.bat, viperGateWayDebug.bat) to launch the Viper.GetWay service via dotnet, alongside adding the bluebird.min.js library to the wwwroot/js/httpVue directory, enabling promise-based JavaScript execution in the frontend.

Viper · high confidence

Introduced the ViperLog module to provide structured logging capabilities. The new \LogBaseModule\ class offers convenience methods (Info, Warn, Error, Fatal) that automatically capture the current request's TraceId and username (uname) to associate logs with specific users and distributed traces. The underlying \ViperLogServiceImp\ implementation constructs \sys\_log\ entities containing trace IDs, usernames, log types, and content, which are then batched and sent via the \ILogService\ interface. This enables better observability by linking log entries to specific users and request contexts.

Anno.ViperLog · high confidence

The ViperService plug-in now supports uploading files via a new 'UpLoadFile' API, which saves the incoming file to the application's base directory. Additionally, a 'GetObjInfo' endpoint has been added to return sample object data, including fields for name, age, height, and total. The service also includes a new 'AnnoFile' class to handle file metadata and content, and a 'Bootstrap' class for service configuration.

Anno.Plugs.ViperService · medium confidence

The ViperService application is introduced, providing a .NET-based service that runs on port 7011 and registers with a central registry at 127.0.0.1:7010. The service is configured to use MySQL as its database, with connection details and timeout settings defined in Anno.config. The service supports command-line arguments for configuration, including port, thread count, timeout, weight, and tracing options, and utilizes Autofac for dependency injection with Thrift-based RPC communication.

ViperService · high confidence

A new cluster dashboard page has been added to display a list of service instances, showing details such as nickname, host, port, timeout, weight, and tags. The page uses Vue.js and Element UI to render cards for each service, with specific CSS styles for both desktop and mobile layouts. The JavaScript file handles data loading and mobile detection.

Viper/wwwroot/html/service · high confidence

Added new Vue components for service analysis (anno-analyse, anno-analyse-detail, anno-timeinterval-analyse, anno-trace, anno-24uservisitdistribute-analyse) that display ECharts-based visualizations for service access, routing, methods, and user visit distribution. Added components for deployment management (anno-deploy-detail, anno-deploy-list) allowing users to configure, start, stop, restart, and copy services on nodes. Added a role management component (anno-role-list) for creating and deleting roles. Added a spreadsheet component (anno-luckysheet) for web-based Excel-like editing. Added a default calendar component (anno-default) and a router header search component (anno-router-header).

Viper/wwwroot/component · high confidence

The repository is initialized as the Viper project, a dashboard and example application for the Anno microservices framework. The solution is restructured to target .NET 6.0 (as defined in Directory.Build.props) and includes new plugin services for monitoring (Anno.Plugs.MonitorService) and distributed locking (Anno.Plugs.DLockService), alongside sample services like HelloWorldService. The project also adds a MIT license, a .gitattributes file, and batch scripts for running the center, gateway, and service components.

(repo-wide) · high confidence

The ViperCenter application now integrates with DingTalk to send real-time notifications about service status changes. When a service goes online, goes offline, becomes unhealthy, or recovers, a Markdown message is posted to the configured DingTalk group. The notification includes the service name, IP, port, timeout, weight, and tags. Additionally, configuration for the DingTalk notification token is read from Anno.config, and the application can be started via the provided batch or shell scripts.

ViperCenter · high confidence

The TraceService plug-in now supports user-defined system logs and links them with distributed tracing. A new \LogBatch\ endpoint allows batch insertion of user logs into the \sys\_log\ table, while a \SysLog\ query endpoint enables paginated retrieval and filtering of these logs. Additionally, a \GetServiceInstances\ method has been added to \RouterModule\, allowing the system to retrieve and display a list of active service instances (host, port, weight, etc.) for cluster overview purposes. The trace query logic in \TraceModule\ has also been updated to support querying by both GlobalTraceId and TraceId.

Anno.Plugs.TraceService · medium confidence

The application now includes custom CSS to style webkit scrollbars (headings, thumb, track) and integrates the Element UI and JSONEditor style sheets. This ensures consistent visual presentation of scrollbars and third-party UI components within the Viper area.

Viper/wwwroot/css · high confidence

The LogicService now enforces stricter access controls and adds new administrative capabilities. A new Authorization filter restricts sensitive operations (password reset, user state editing, role management) to the 'admin' user. Additionally, the 'NotChangePassword' filter prevents password changes for the 'anno' and 'yrm' accounts. The PlatformModule gains a new 'GetRolePage' endpoint for paginated role queries. Finally, the ReportModule's trace statistics query is updated to support both MySQL and SQL Server, using specific syntax for each to ensure compatibility.

Anno.Plugs.LogicService · high confidence

The Viper gateway now exposes new endpoints for service discovery (AnnoApi/ServiceInstance, AnnoApi/DeployService) and a flexible routing template (AnnoApi/{channel}/{router}/{method}/{nodeName?}) that supports optional node names and tag-based routing. Rate-limiting configuration has been expanded to support per-IP policies (IplimitRange) alongside existing tag-based limits, and the system now tracks active gateway requests via a new UtilEngineCounter. Additionally, a new FileToBase64 extension and a background job utility (UtilJob) for garbage collection have been added to the Viper/Extensions directory.

Viper/Extensions · medium confidence

The monitoring functionality has been refactored into separate, dedicated files: MonitorHub.cs, TaskManager.cs, WatchDataUtil.cs, and WatchUser.cs. Previously, these components were embedded within SystemHub.cs. This change improves code organization and maintainability by separating the SignalR hub logic, the background task manager responsible for collecting and pushing performance data, and the utility classes used for tracking connected users and their watched services.

Viper/Hubs · high confidence

Added new HTML templates for role permission configuration (func\_roles\_config.html), a generic component wrapper (component.html), and an ECharts-enabled component page (component\_echarts.html). Updated the function configuration page (fconfig.html) with improved styling and layout adjustments. The welcome page (welcome.html) was also added, providing a dashboard-style interface with steps and progress indicators. All pages integrate with the existing JavaScript and CSS assets, including Element UI and ECharts libraries, to support the new UI components and layout structures.

Viper/wwwroot/html · high confidence

The StudentWork module's legacy frontend assets have been removed, including the main home view (Index.cshtml) which contained the primary Vue.js-based navigation and menu logic, the Simulation.cshtml view used for API testing, the associated CSS file (element-ui-index.css) for the Element UI framework, and the batch scripts (swWeb.bat, swWebDebug.bat) used to launch the application.

StudentWork, StudentWorkCenter, StudentWorkService · high confidence

The project has removed the entire \ligerUI\ JavaScript library and its associated plugin files (including \ligerui.all.js\, \ligerAccordion.js\, \ligerButton.js\, \ligerCheckBox.js\, \ligerCheckBoxList.js\, \ligerComboBox.js\, \ligerDateEditor.js\, \ligerDialog.js\, and \ligerDrag.js\) from the \StudentWork/wwwroot/js/lib/ligerUI\ directory. This eliminates the client-side UI framework and its specific widget implementations from the application.

StudentWork/wwwroot/js · high confidence

The default database provider for the application has been changed from a hardcoded MySQL to a configurable setting. Users can now specify the database type (e.g., SQL Server) via the \DbType\ configuration key, allowing the application to connect to different database systems without code changes.

Anno.Infrastructure · medium confidence

The trace and router HTML pages (indexnew, router, detail, routerdetail) have been moved to the Viper project. The JavaScript code has been updated to use the new \anno\ namespace for API calls (replacing \bif\) and to use \anno.GetUrlParms\ instead of \bif.GetUrlParms\. Additionally, the pages now reference local JavaScript and CSS files (e.g., \../../js/jquery.min.js\, \../../css/common.css\) rather than CDN links, and the router list view now includes a clickable link to view system logs associated with each trace entry.

Viper/wwwroot/html/trace · medium confidence

The database directory now includes updated SQL scripts for both MySQL and Microsoft SQL Server. The MySQL scripts (Viper20200926184831.sql, Viper20210201\_01.sql, viper20210617\_01.sql) and the new SQL Server script (mssql20210708.sql) define the schema for tables including bif\_company, sys\_func, and sys\_func\_roles\_link. The SQL Server script additionally includes the sys\_log and sys\_member tables, reflecting a broader schema update for that platform.

database · medium confidence

The \MvcCallAnno\ sample application has been updated to use the latest \Anno\ framework packages, including \Anno.Rpc.Client\ version 2.2.0.2, \Anno.EngineData\ version 2.2.0.2, and \Anno.Loader\ version 1.7.0.3. The sample now utilizes \Autofac\ for dependency injection, with new configuration files (\AutoFacConfig.cs\, \IocManager.cs\) and a \ValuesController\ that demonstrates calling remote services via the \AnnoProxyBuilder\. This allows users to see how to integrate the Anno RPC client with an ASP.NET Web API project using Autofac for service resolution.

Samples/Mvc · medium confidence

The system log model has been updated to support distributed tracing and better context for logs. The \sys\_log\ entity now includes a \TraceId\ field to link logs to specific execution chains, and an \AppName\ field to identify the source application. This replaces the previous \bif\_log\ model, which lacked trace correlation and application context.

Trace · high confidence

The Viper frontend has been significantly updated to support a tabbed navigation interface on the home page, allowing users to open and switch between multiple internal pages via iframes. The layout now includes a collapsible sidebar menu, a user profile dropdown, and system status tags. Mobile responsiveness has been improved, with the menu supporting swipe gestures and the layout adapting to smaller screens. Additionally, the login page now features default credentials (username: 'anno', password: '123456') and a link to the official documentation.

Viper/Views · high confidence

The Viper.Test project now includes new test classes for validating core framework capabilities: DLockTest exercises the distributed lock mechanism under concurrent access; RpcTest verifies RPC client connectivity and method invocation; KvStorageTest checks key-value storage operations; and RedisTest validates Redis integration for both scalar and complex object serialization. These tests ensure the underlying services function correctly in isolation.

Viper.Test · high confidence

The project has been upgraded to use the Anno framework version 2.2.0.2 across multiple components, including the core EngineData, Loader, Const, Log, and RPC packages. This update is accompanied by upgrades to supporting libraries such as Newtonsoft.Json (to 13.0.1) and StackExchange.Redis (to 2.6.70). Additionally, the solution has been reorganized: the 'StudentWork' and 'Viper' services have been renamed and restructured (e.g., StudentWorkService renamed to ViperService), and sample projects like HelloWorld and SoEasyService have been added or moved to the Samples directory. The Microsoft.CSharp reference was also migrated from a direct assembly reference to a NuGet package.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 31 → 28 (-2.9)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 51 → 47 (-3.9)
• Architecture 93 → 93 (+0.0)
• Maturity 55 → 55 (+0.0)
• Readiness 24 → 20 (-3.6)
• Security 30 → 21 (-9.0)
• Domain Modelling 97 (new)
• Event-Driven 100 → 100 (+0.0)
• Accessibility 25 → 29 (+3.6)
• Performance 54 → 54 (+0.0)

• Bounded contexts not declared
• Build did not complete in the analyzer
• Duplicated block (12 lines × 2) (Viper/Extensions/Utils/UtilService.cs)
• Duplicated block (12 lines × 2) (Viper/Extensions/Utils/UtilService.cs)
• Duplicated block (12 lines × 3) (Trace/Anno.Model/BaseModel/Entity.cs)
• Duplicated block (15 lines × 2) (Trace/Anno.Model/BaseModel/Entity.cs)
• Duplicated block (17 lines × 2) (Anno.Plugs.TraceService/TraceModule.cs)
• Duplicated block (21 lines × 2) (Trace/Anno.Model/BaseModel/Entity.cs)
• Duplicated block (35 lines × 2) (ViperService/Program.cs)
• Duplicated block (8 lines × 3) (Trace/Anno.Model/BaseModel/Entity.cs)
• Inconsistent naming for Member and Role entities. The domain uses 'SysMember' and 'Role', while the model layer uses 'sys_member' and 'sys_roles'. This creates a disconnect between the domain model and the data model/DTOs.
• Inconsistent naming for bash command wrappers. Some are named after the command itself (e.g., Mv, Cat, Grep), while others use a generic Command or Output. This makes it hard to distinguish between specific command wrappers and generic utilities.
• Inconsistent naming for the 'Member' entity and its related tables/DTOs. Some use 'SysMember' or 'sys_member' (e.g., Anno.Domain.Member.SysMember), while others use the raw table name 'sys_member' (e.g., Anno.Model.sys_member). Similarly, 'Role' is sometimes 'SysRole' or 'sys_roles'. The model layer mixes POCO names with database table names.
• LLM evaluation failed
• No exposed public API
• Test reliability not measured — no test run produced results
• XML-doc coverage: HelloWorldService (Samples/HelloWorldService/HelloWorldService.csproj)
• XML-doc coverage: ViperService (ViperService/ViperService.csproj)
• dormant codebase — no living knowledge left to concentrate

• (anonymous)::(anonymous)::(anonymous)::parse (cognitive 26) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::(anonymous)::parse (cyclomatic 28) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Ai (cyclomatic 16) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Ao::_setCheckedKeys (cognitive 16) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Ec::fromString (cognitive 31) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Ec::fromString (cyclomatic 22) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Oo::e (cognitive 20) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Oo::e (cyclomatic 23) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Pa (cyclomatic 16) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Qs (cyclomatic 17) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Tn::updateColumnsWidth (cognitive 23) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Tn::updateElsHeight (cognitive 26) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Tn::updateElsHeight (cyclomatic 20) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Y (cognitive 27) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::Y (cyclomatic 31) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::b (cognitive 38) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::b (cyclomatic 18) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::closeModal (cognitive 17) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::createPopper (cognitive 16) (Viper/wwwroot/js/element-ui-index.js)
• (anonymous)::(anonymous)::createPopper (cyclomatic 18) (Viper/wwwroot/js/element-ui-index.js)
• …and 188 more

• Unchanged — 1 HTTP endpoints

• Unchanged — 4 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

duyanming/Viper was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.