@cryptotaxi247 / netdata-1 / commits / ff6cde51f

Active Directory (windows.plugin) (#22093)

thiagoftsm committed Apr 24, 2026 at 11:09 UTC ff6cde51f4e7347d4d198b27c3292701e866b30a
3 files changed +3973 -238
src/collectors/windows.plugin/metadata.yaml
+532 -16
@@ -2352,7 +2352,7 @@ modules:
2352 overview:
2353 data_collection:
2354 metrics_description: |
2355 - This collector monitors Active Directory IO and queries.
2355 + This collector monitors Active Directory directory operations, replication, LDAP activity, binds, queueing, database, cleanup, security descriptor propagation, and SAM metrics.
2356 method_description: |
2357 It queries DirectoryServices object from Perflib in order to gather the metrics.
2358 supported_platforms:
@@ -2407,6 +2407,54 @@ modules:
2407 description: "These metrics refer to Active Directory."
2408 labels: []
2409 metrics:
2410 + - name: ad.address_book_ambiguous_name_resolution
2411 + description: Address book ambiguous name resolution
2412 + unit: operations/s
2413 + chart_type: line
2414 + dimensions:
2415 + - name: ambiguous_name_resolution
2416 + - name: ad.address_book_browse
2417 + description: Address book browse operations
2418 + unit: operations/s
2419 + chart_type: line
2420 + dimensions:
2421 + - name: browse
2422 + - name: ad.address_book_find
2423 + description: Address book matches
2424 + unit: operations/s
2425 + chart_type: line
2426 + dimensions:
2427 + - name: find
2428 + - name: ad.address_book_property_read
2429 + description: Address book property reads
2430 + unit: operations/s
2431 + chart_type: line
2432 + dimensions:
2433 + - name: property_read
2434 + - name: ad.address_book_search
2435 + description: Address book searches
2436 + unit: operations/s
2437 + chart_type: line
2438 + dimensions:
2439 + - name: search
2440 + - name: ad.address_book_proxy_search
2441 + description: Address book proxy searches
2442 + unit: operations/s
2443 + chart_type: line
2444 + dimensions:
2445 + - name: proxy_search
2446 + - name: ad.address_book_client_sessions
2447 + description: Address book client sessions
2448 + unit: sessions
2449 + chart_type: line
2450 + dimensions:
2451 + - name: sessions
2452 + - name: ad.approximate_highest_dnt
2453 + description: Approximate highest distinguished name tag
2454 + unit: dnt
2455 + chart_type: line
2456 + dimensions:
2457 + - name: dnt
2458 - name: ad.directory_operations
2459 description: AD directory operations
2460 unit: operations/s
@@ -2415,12 +2463,42 @@ modules:
2463 - name: read
2464 - name: write
2465 - name: search
2466 + - name: ad.searches_base
2467 + description: Directory base searches
2468 + unit: searches/s
2469 + chart_type: line
2470 + dimensions:
2471 + - name: base
2472 + - name: ad.searches_subtree
2473 + description: Directory subtree searches
2474 + unit: searches/s
2475 + chart_type: line
2476 + dimensions:
2477 + - name: subtree
2478 + - name: ad.searches_one_level
2479 + description: Directory one-level searches
2480 + unit: searches/s
2481 + chart_type: line
2482 + dimensions:
2483 + - name: one_level
2484 - name: ad.name_cache_lookups
2485 description: Name cache lookups
2486 unit: lookups/s
2487 chart_type: line
2488 dimensions:
2489 - name: lookups
2490 + - name: ad.name_cache_hits
2491 + description: Name cache hits
2492 + unit: hits/s
2493 + chart_type: line
2494 + dimensions:
2495 + - name: hits
2496 + - name: ad.ldap_searches
2497 + description: LDAP client search operations
2498 + unit: searches/s
2499 + chart_type: line
2500 + dimensions:
2501 + - name: searches
2502 - name: ad.dra_replication_properties_updated
2503 description: DRA replication properties updated
2504 unit: properties/s
@@ -2434,25 +2512,55 @@ modules:
2512 dimensions:
2513 - name: inbound
2514 - name: ad.dra_replication_intersite_compressed_traffic
2437 - description: DRA replication compressed traffic withing site
2515 + description: DRA replication compressed traffic between sites
2516 unit: bytes/s
2517 chart_type: area
2518 dimensions:
2519 - name: inbound
2520 - name: outbound
2443 - - name: ad.dra_replication_intrasite_compressed_traffic
2444 - description: DRA replication compressed traffic between sites
2521 + - name: ad.dra_replication_intrasite_uncompressed_traffic
2522 + description: DRA replication uncompressed traffic within site
2523 unit: bytes/s
2524 chart_type: area
2525 dimensions:
2526 - name: inbound
2527 - name: outbound
2450 - - name: ad.dra_replication_pending_syncs
2451 - description: DRA replication pending syncs
2452 - unit: syncs
2528 + - name: ad.replication_highest_usn_committed
2529 + description: Highest replication committed update sequence number
2530 + unit: usn/s
2531 chart_type: line
2532 dimensions:
2455 - - name: pending
2533 + - name: committed
2534 + - name: ad.replication_highest_usn_issued
2535 + description: Highest replication issued update sequence number
2536 + unit: usn/s
2537 + chart_type: line
2538 + dimensions:
2539 + - name: issued
2540 + - name: ad.replication_inbound_sync_objects_remaining
2541 + description: Replication inbound sync objects remaining
2542 + unit: objects
2543 + chart_type: line
2544 + dimensions:
2545 + - name: remaining
2546 + - name: ad.replication_inbound_link_value_updates_remaining
2547 + description: Replication inbound link value updates remaining
2548 + unit: updates
2549 + chart_type: line
2550 + dimensions:
2551 + - name: remaining
2552 + - name: ad.replication_inbound_objects_updated
2553 + description: Replication inbound objects updated
2554 + unit: objects/s
2555 + chart_type: line
2556 + dimensions:
2557 + - name: updated
2558 + - name: ad.replication_inbound_objects_filtered
2559 + description: Replication inbound objects filtered
2560 + unit: objects/s
2561 + chart_type: line
2562 + dimensions:
2563 + - name: filtered
2564 - name: ad.dra_replication_pending_syncs
2565 description: DRA replication pending syncs
2566 unit: syncs
@@ -2465,12 +2573,78 @@ modules:
2573 chart_type: line
2574 dimensions:
2575 - name: request
2468 - - name: ad.name_cache_hits
2469 - description: Name cache hits
2470 - unit: hits/s
2576 + - name: ad.replication_pending_operations
2577 + description: Replication pending operations
2578 + unit: operations
2579 chart_type: line
2580 dimensions:
2473 - - name: hits
2581 + - name: pending
2582 + - name: ad.replication_sync_requests_success
2583 + description: Replication sync requests successful
2584 + unit: requests/s
2585 + chart_type: line
2586 + dimensions:
2587 + - name: success
2588 + - name: ad.replication_sync_requests_schema_mismatch_failure
2589 + description: Replication sync requests failed due to schema mismatch
2590 + unit: requests/s
2591 + chart_type: line
2592 + dimensions:
2593 + - name: failure
2594 + - name: ad.name_translations_client
2595 + description: Client name translations
2596 + unit: translations/s
2597 + chart_type: line
2598 + dimensions:
2599 + - name: client
2600 + - name: ad.name_translations_server
2601 + description: Server name translations
2602 + unit: translations/s
2603 + chart_type: line
2604 + dimensions:
2605 + - name: server
2606 + - name: ad.change_monitors_registered
2607 + description: Registered change monitors
2608 + unit: monitors
2609 + chart_type: line
2610 + dimensions:
2611 + - name: registered
2612 + - name: ad.change_monitor_updates_pending
2613 + description: Pending change monitor updates
2614 + unit: updates
2615 + chart_type: line
2616 + dimensions:
2617 + - name: pending
2618 + - name: ad.directory_search_suboperations
2619 + description: Directory search suboperations
2620 + unit: operations/s
2621 + chart_type: line
2622 + dimensions:
2623 + - name: suboperations
2624 + - name: ad.security_descriptor_propagation_events
2625 + description: Security descriptor propagation events
2626 + unit: events/s
2627 + chart_type: line
2628 + dimensions:
2629 + - name: events
2630 + - name: ad.security_descriptor_propagation_events_queued
2631 + description: Security descriptor propagation events queued
2632 + unit: events
2633 + chart_type: line
2634 + dimensions:
2635 + - name: queued
2636 + - name: ad.security_descriptor_propagation_access_wait
2637 + description: Security descriptor propagation access wait
2638 + unit: seconds
2639 + chart_type: line
2640 + dimensions:
2641 + - name: wait
2642 + - name: ad.security_descriptor_propagation_items_queued
2643 + description: Security descriptor propagation items queued
2644 + unit: items
2645 + chart_type: line
2646 + dimensions:
2647 + - name: queued
2648 - name: ad.ds_threads
2649 description: Directory Service threads
2650 unit: threads
@@ -2483,18 +2657,360 @@ modules:
2657 chart_type: line
2658 dimensions:
2659 - name: last_bind
2486 - - name: ad.ldap_searches
2487 - description: LDAP client search operations
2488 - unit: searches/s
2660 + - name: ad.binds_digest
2661 + description: Digest binds
2662 + unit: binds/s
2663 chart_type: line
2664 dimensions:
2491 - - name: searches
2665 + - name: digest
2666 + - name: ad.binds_ds_client
2667 + description: DS client binds
2668 + unit: binds/s
2669 + chart_type: line
2670 + dimensions:
2671 + - name: ds_client
2672 + - name: ad.binds_ds_server
2673 + description: DS server binds
2674 + unit: binds/s
2675 + chart_type: line
2676 + dimensions:
2677 + - name: ds_server
2678 + - name: ad.binds_external
2679 + description: External binds
2680 + unit: binds/s
2681 + chart_type: line
2682 + dimensions:
2683 + - name: external
2684 + - name: ad.binds_fast
2685 + description: Fast binds
2686 + unit: binds/s
2687 + chart_type: line
2688 + dimensions:
2689 + - name: fast
2690 + - name: ad.binds_negotiate
2691 + description: Negotiated binds
2692 + unit: binds/s
2693 + chart_type: line
2694 + dimensions:
2695 + - name: negotiate
2696 + - name: ad.binds_ntlm
2697 + description: NTLM binds
2698 + unit: binds/s
2699 + chart_type: line
2700 + dimensions:
2701 + - name: ntlm
2702 + - name: ad.binds_simple
2703 + description: Simple binds
2704 + unit: binds/s
2705 + chart_type: line
2706 + dimensions:
2707 + - name: simple
2708 + - name: ad.binds_ldap
2709 + description: LDAP successful binds
2710 + unit: binds/s
2711 + chart_type: line
2712 + dimensions:
2713 + - name: ldap
2714 + - name: ad.ldap_closed_connections
2715 + description: LDAP closed connections
2716 + unit: connections/s
2717 + chart_type: line
2718 + dimensions:
2719 + - name: closed
2720 + - name: ad.ldap_opened_connections_ldap
2721 + description: LDAP opened connections
2722 + unit: connections/s
2723 + chart_type: line
2724 + dimensions:
2725 + - name: ldap
2726 + - name: ad.ldap_opened_connections_ldaps
2727 + description: LDAPS opened connections
2728 + unit: connections/s
2729 + chart_type: line
2730 + dimensions:
2731 + - name: ldaps
2732 + - name: ad.ldap_active_threads
2733 + description: LDAP active threads
2734 + unit: threads
2735 + chart_type: line
2736 + dimensions:
2737 + - name: active
2738 + - name: ad.ldap_udp_operations
2739 + description: LDAP UDP operations
2740 + unit: operations/s
2741 + chart_type: line
2742 + dimensions:
2743 + - name: udp
2744 + - name: ad.ldap_writes
2745 + description: LDAP writes
2746 + unit: writes/s
2747 + chart_type: line
2748 + dimensions:
2749 + - name: writes
2750 + - name: ad.ldap_client_sessions
2751 + description: LDAP client sessions
2752 + unit: sessions
2753 + chart_type: line
2754 + dimensions:
2755 + - name: sessions
2756 + - name: ad.atq_outstanding_requests
2757 + description: Outstanding requests
2758 + unit: requests
2759 + chart_type: line
2760 + dimensions:
2761 + - name: outstanding
2762 + - name: ad.atq_estimated_delay
2763 + description: Estimated queue delay
2764 + unit: seconds
2765 + chart_type: line
2766 + dimensions:
2767 + - name: delay
2768 - name: ad.atq_average_request_latency
2769 description: Average request processing time
2770 unit: seconds
2771 chart_type: line
2772 dimensions:
2773 - name: time
2774 + - name: ad.atq_current_threads_ldap
2775 + description: Current ATQ LDAP threads
2776 + unit: threads
2777 + chart_type: line
2778 + dimensions:
2779 + - name: ldap
2780 + - name: ad.atq_current_threads_other
2781 + description: Current ATQ other threads
2782 + unit: threads
2783 + chart_type: line
2784 + dimensions:
2785 + - name: other
2786 + - name: ad.atq_current_threads_total
2787 + description: Current ATQ total threads
2788 + unit: threads
2789 + chart_type: line
2790 + dimensions:
2791 + - name: total
2792 + - name: ad.database_operations
2793 + description: AD database operations
2794 + unit: operations/s
2795 + chart_type: line
2796 + dimensions:
2797 + - name: add
2798 + - name: delete
2799 + - name: modify
2800 + - name: recycle
2801 + - name: ad.directory_reads
2802 + description: Directory reads
2803 + unit: reads/s
2804 + chart_type: line
2805 + dimensions:
2806 + - name: read
2807 + - name: ad.directory_searches
2808 + description: Directory searches
2809 + unit: searches/s
2810 + chart_type: line
2811 + dimensions:
2812 + - name: search
2813 + - name: ad.directory_writes
2814 + description: Directory writes
2815 + unit: writes/s
2816 + chart_type: line
2817 + dimensions:
2818 + - name: write
2819 + - name: ad.replication_inbound_object_updates_remaining
2820 + description: Replication inbound object updates remaining
2821 + unit: updates
2822 + chart_type: line
2823 + dimensions:
2824 + - name: remaining
2825 + - name: ad.replication_inbound_values_dns_only
2826 + description: DRA replication inbound values DNs only
2827 + unit: values/s
2828 + chart_type: line
2829 + dimensions:
2830 + - name: dns_only
2831 + - name: ad.replication_inbound_values_total
2832 + description: DRA replication inbound values total
2833 + unit: values/s
2834 + chart_type: line
2835 + dimensions:
2836 + - name: total
2837 + - name: ad.replication_outbound_objects_filtered
2838 + description: Replication outbound objects filtered
2839 + unit: objects/s
2840 + chart_type: line
2841 + dimensions:
2842 + - name: filtered
2843 + - name: ad.replication_outbound_objects
2844 + description: Replication outbound objects
2845 + unit: objects/s
2846 + chart_type: line
2847 + dimensions:
2848 + - name: objects
2849 + - name: ad.replication_outbound_properties
2850 + description: Replication outbound properties
2851 + unit: properties/s
2852 + chart_type: line
2853 + dimensions:
2854 + - name: properties
2855 + - name: ad.replication_outbound_values_dns_only
2856 + description: DRA replication outbound values DNs only
2857 + unit: values/s
2858 + chart_type: line
2859 + dimensions:
2860 + - name: dns_only
2861 + - name: ad.replication_outbound_values_total
2862 + description: DRA replication outbound values total
2863 + unit: values/s
2864 + chart_type: line
2865 + dimensions:
2866 + - name: total
2867 + - name: ad.replication_threads_getting_nc_changes
2868 + description: DRA threads getting NC changes
2869 + unit: threads
2870 + chart_type: line
2871 + dimensions:
2872 + - name: threads
2873 + - name: ad.replication_threads_getting_nc_changes_holding_semaphore
2874 + description: DRA threads getting NC changes holding semaphore
2875 + unit: threads
2876 + chart_type: line
2877 + dimensions:
2878 + - name: threads
2879 + - name: ad.transitive_operations
2880 + description: Transitive operations
2881 + unit: operations/s
2882 + chart_type: line
2883 + dimensions:
2884 + - name: operations
2885 + - name: ad.transitive_suboperations
2886 + description: Transitive suboperations
2887 + unit: suboperations/s
2888 + chart_type: line
2889 + dimensions:
2890 + - name: suboperations
2891 + - name: ad.replication_inbound_bytes_total
2892 + description: DRA replication inbound bytes total
2893 + unit: bytes/s
2894 + chart_type: line
2895 + dimensions:
2896 + - name: inbound
2897 + - name: ad.replication_outbound_bytes_total
2898 + description: DRA replication outbound bytes total
2899 + unit: bytes/s
2900 + chart_type: line
2901 + dimensions:
2902 + - name: outbound
2903 + - name: ad.link_values_cleaned
2904 + description: Link values cleaned
2905 + unit: values/s
2906 + chart_type: line
2907 + dimensions:
2908 + - name: cleaned
2909 + - name: ad.phantom_objects_cleaned
2910 + description: Phantom objects cleaned
2911 + unit: objects/s
2912 + chart_type: line
2913 + dimensions:
2914 + - name: cleaned
2915 + - name: ad.phantom_objects_visited
2916 + description: Phantom objects visited
2917 + unit: objects/s
2918 + chart_type: line
2919 + dimensions:
2920 + - name: visited
2921 + - name: ad.tombstoned_objects_collected
2922 + description: Tombstoned objects collected
2923 + unit: objects/s
2924 + chart_type: line
2925 + dimensions:
2926 + - name: collected
2927 + - name: ad.tombstoned_objects_visited
2928 + description: Tombstoned objects visited
2929 + unit: objects/s
2930 + chart_type: line
2931 + dimensions:
2932 + - name: visited
2933 + - name: ad.sam_group_membership_evaluations
2934 + description: SAM group membership evaluations
2935 + unit: evaluations/s
2936 + chart_type: line
2937 + dimensions:
2938 + - name: global
2939 + - name: domain_local
2940 + - name: universal
2941 + - name: ad.sam_group_membership_global_catalog_evaluations
2942 + description: SAM group membership global catalog evaluations
2943 + unit: evaluations/s
2944 + chart_type: line
2945 + dimensions:
2946 + - name: global_catalog
2947 + - name: ad.sam_group_membership_evaluations_nontransitive
2948 + description: SAM non-transitive membership evaluations
2949 + unit: evaluations/s
2950 + chart_type: line
2951 + dimensions:
2952 + - name: nontransitive
2953 + - name: ad.sam_group_membership_evaluations_transitive
2954 + description: SAM transitive membership evaluations
2955 + unit: evaluations/s
2956 + chart_type: line
2957 + dimensions:
2958 + - name: transitive
2959 + - name: ad.sam_group_evaluation_latency
2960 + description: SAM group evaluation latency
2961 + unit: latency
2962 + chart_type: line
2963 + dimensions:
2964 + - name: account_group
2965 + - name: resource_group
2966 + - name: ad.sam_computer_creation_requests
2967 + description: SAM computer creation requests
2968 + unit: requests/s
2969 + chart_type: line
2970 + dimensions:
2971 + - name: request
2972 + - name: ad.sam_computer_creation_successful_requests
2973 + description: SAM successful computer creation requests
2974 + unit: requests/s
2975 + chart_type: line
2976 + dimensions:
2977 + - name: success
2978 + - name: ad.sam_user_creation_requests
2979 + description: SAM user creation requests
2980 + unit: requests/s
2981 + chart_type: line
2982 + dimensions:
2983 + - name: request
2984 + - name: ad.sam_user_creation_successful_requests
2985 + description: SAM successful user creation requests
2986 + unit: requests/s
2987 + chart_type: line
2988 + dimensions:
2989 + - name: success
2990 + - name: ad.sam_query_display_requests
2991 + description: SAM query display requests
2992 + unit: requests/s
2993 + chart_type: line
2994 + dimensions:
2995 + - name: query
2996 + - name: ad.sam_enumerations
2997 + description: SAM enumerations
2998 + unit: enumerations/s
2999 + chart_type: line
3000 + dimensions:
3001 + - name: enumeration
3002 + - name: ad.sam_membership_changes
3003 + description: SAM membership changes
3004 + unit: changes/s
3005 + chart_type: line
3006 + dimensions:
3007 + - name: change
3008 + - name: ad.sam_password_changes
3009 + description: SAM password changes
3010 + unit: changes/s
3011 + chart_type: line
3012 + dimensions:
3013 + - name: change
3014 - meta:
3015 plugin_name: windows.plugin
3016 module_name: PerflibADCS
src/collectors/windows.plugin/perflib-ad.c
+3355 -220
@@ -3,6 +3,298 @@
3 #include "windows_plugin.h"
4 #include "windows-internals.h"
5
6 +static void netdata_ad_address_book_ambiguous_name_resolution(
7 + PERF_DATA_BLOCK *pDataBlock,
8 + PERF_OBJECT_TYPE *pObjectType,
9 + int update_every)
10 +{
11 + static COUNTER_DATA addressBookANRPerSec = {.key = "AB ANR/sec"};
12 + static RRDSET *st_address_book_ambiguous_name_resolution = NULL;
13 + static RRDDIM *rd_address_book_ambiguous_name_resolution = NULL;
14 +
15 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &addressBookANRPerSec))
16 + return;
17 +
18 + if (unlikely(!st_address_book_ambiguous_name_resolution)) {
19 + st_address_book_ambiguous_name_resolution = rrdset_create_localhost(
20 + "ad",
21 + "address_book_ambiguous_name_resolution",
22 + NULL,
23 + "address_book",
24 + "ad.address_book_ambiguous_name_resolution",
25 + "Address book ambiguous name resolution",
26 + "operations/s",
27 + PLUGIN_WINDOWS_NAME,
28 + "PerflibAD",
29 + PRIO_AD_ADDRESS_BOOK_AMBIGUOUS_NAME_RESOLUTION,
30 + update_every,
31 + RRDSET_TYPE_LINE);
32 +
33 + rd_address_book_ambiguous_name_resolution = rrddim_add(
34 + st_address_book_ambiguous_name_resolution,
35 + "ambiguous_name_resolution",
36 + NULL,
37 + 1,
38 + 1,
39 + RRD_ALGORITHM_INCREMENTAL);
40 + }
41 +
42 + rrddim_set_by_pointer(
43 + st_address_book_ambiguous_name_resolution,
44 + rd_address_book_ambiguous_name_resolution,
45 + (collected_number)addressBookANRPerSec.current.Data);
46 + rrdset_done(st_address_book_ambiguous_name_resolution);
47 +}
48 +
49 +static void netdata_ad_address_book_browse(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
50 +{
51 + static COUNTER_DATA addressBookBrowsesPerSec = {.key = "AB Browses/sec"};
52 + static RRDSET *st_address_book_browse = NULL;
53 + static RRDDIM *rd_address_book_browse = NULL;
54 +
55 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &addressBookBrowsesPerSec))
56 + return;
57 +
58 + if (unlikely(!st_address_book_browse)) {
59 + st_address_book_browse = rrdset_create_localhost(
60 + "ad",
61 + "address_book_browse",
62 + NULL,
63 + "address_book",
64 + "ad.address_book_browse",
65 + "Address book browse operations",
66 + "operations/s",
67 + PLUGIN_WINDOWS_NAME,
68 + "PerflibAD",
69 + PRIO_AD_ADDRESS_BOOK_BROWSE,
70 + update_every,
71 + RRDSET_TYPE_LINE);
72 +
73 + rd_address_book_browse = rrddim_add(st_address_book_browse, "browse", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
74 + }
75 +
76 + rrddim_set_by_pointer(
77 + st_address_book_browse, rd_address_book_browse, (collected_number)addressBookBrowsesPerSec.current.Data);
78 + rrdset_done(st_address_book_browse);
79 +}
80 +
81 +static void netdata_ad_address_book_find(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
82 +{
83 + static COUNTER_DATA addressBookMatchesPerSec = {.key = "AB Matches/sec"};
84 + static RRDSET *st_address_book_find = NULL;
85 + static RRDDIM *rd_address_book_find = NULL;
86 +
87 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &addressBookMatchesPerSec))
88 + return;
89 +
90 + if (unlikely(!st_address_book_find)) {
91 + st_address_book_find = rrdset_create_localhost(
92 + "ad",
93 + "address_book_find",
94 + NULL,
95 + "address_book",
96 + "ad.address_book_find",
97 + "Address book matches",
98 + "operations/s",
99 + PLUGIN_WINDOWS_NAME,
100 + "PerflibAD",
101 + PRIO_AD_ADDRESS_BOOK_FIND,
102 + update_every,
103 + RRDSET_TYPE_LINE);
104 +
105 + rd_address_book_find = rrddim_add(st_address_book_find, "find", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
106 + }
107 +
108 + rrddim_set_by_pointer(
109 + st_address_book_find, rd_address_book_find, (collected_number)addressBookMatchesPerSec.current.Data);
110 + rrdset_done(st_address_book_find);
111 +}
112 +
113 +static void
114 +netdata_ad_address_book_property_read(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
115 +{
116 + static COUNTER_DATA addressBookPropertyReadsPerSec = {.key = "AB Property Reads/sec"};
117 + static RRDSET *st_address_book_property_read = NULL;
118 + static RRDDIM *rd_address_book_property_read = NULL;
119 +
120 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &addressBookPropertyReadsPerSec))
121 + return;
122 +
123 + if (unlikely(!st_address_book_property_read)) {
124 + st_address_book_property_read = rrdset_create_localhost(
125 + "ad",
126 + "address_book_property_read",
127 + NULL,
128 + "address_book",
129 + "ad.address_book_property_read",
130 + "Address book property reads",
131 + "operations/s",
132 + PLUGIN_WINDOWS_NAME,
133 + "PerflibAD",
134 + PRIO_AD_ADDRESS_BOOK_PROPERTY_READ,
135 + update_every,
136 + RRDSET_TYPE_LINE);
137 +
138 + rd_address_book_property_read =
139 + rrddim_add(st_address_book_property_read, "property_read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
140 + }
141 +
142 + rrddim_set_by_pointer(
143 + st_address_book_property_read,
144 + rd_address_book_property_read,
145 + (collected_number)addressBookPropertyReadsPerSec.current.Data);
146 + rrdset_done(st_address_book_property_read);
147 +}
148 +
149 +static void netdata_ad_address_book_search(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
150 +{
151 + static COUNTER_DATA addressBookSearchesPerSec = {.key = "AB Searches/sec"};
152 + static RRDSET *st_address_book_search = NULL;
153 + static RRDDIM *rd_address_book_search = NULL;
154 +
155 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &addressBookSearchesPerSec))
156 + return;
157 +
158 + if (unlikely(!st_address_book_search)) {
159 + st_address_book_search = rrdset_create_localhost(
160 + "ad",
161 + "address_book_search",
162 + NULL,
163 + "address_book",
164 + "ad.address_book_search",
165 + "Address book searches",
166 + "operations/s",
167 + PLUGIN_WINDOWS_NAME,
168 + "PerflibAD",
169 + PRIO_AD_ADDRESS_BOOK_SEARCH,
170 + update_every,
171 + RRDSET_TYPE_LINE);
172 +
173 + rd_address_book_search = rrddim_add(st_address_book_search, "search", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
174 + }
175 +
176 + rrddim_set_by_pointer(
177 + st_address_book_search, rd_address_book_search, (collected_number)addressBookSearchesPerSec.current.Data);
178 + rrdset_done(st_address_book_search);
179 +}
180 +
181 +static void
182 +netdata_ad_address_book_proxy_search(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
183 +{
184 + static COUNTER_DATA addressBookProxyLookupsPerSec = {.key = "AB Proxy Lookups/sec"};
185 + static RRDSET *st_address_book_proxy_search = NULL;
186 + static RRDDIM *rd_address_book_proxy_search = NULL;
187 +
188 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &addressBookProxyLookupsPerSec))
189 + return;
190 +
191 + if (unlikely(!st_address_book_proxy_search)) {
192 + st_address_book_proxy_search = rrdset_create_localhost(
193 + "ad",
194 + "address_book_proxy_search",
195 + NULL,
196 + "address_book",
197 + "ad.address_book_proxy_search",
198 + "Address book proxy searches",
199 + "operations/s",
200 + PLUGIN_WINDOWS_NAME,
201 + "PerflibAD",
202 + PRIO_AD_ADDRESS_BOOK_PROXY_SEARCH,
203 + update_every,
204 + RRDSET_TYPE_LINE);
205 +
206 + rd_address_book_proxy_search =
207 + rrddim_add(st_address_book_proxy_search, "proxy_search", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
208 + }
209 +
210 + rrddim_set_by_pointer(
211 + st_address_book_proxy_search,
212 + rd_address_book_proxy_search,
213 + (collected_number)addressBookProxyLookupsPerSec.current.Data);
214 + rrdset_done(st_address_book_proxy_search);
215 +}
216 +
217 +static void
218 +netdata_ad_address_book_client_sessions(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
219 +{
220 + static COUNTER_DATA addressBookClientSessions = {.key = "AB Client Sessions"};
221 + static RRDSET *st_address_book_client_sessions = NULL;
222 + static RRDDIM *rd_address_book_client_sessions = NULL;
223 +
224 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &addressBookClientSessions))
225 + return;
226 +
227 + if (unlikely(!st_address_book_client_sessions)) {
228 + st_address_book_client_sessions = rrdset_create_localhost(
229 + "ad",
230 + "address_book_client_sessions",
231 + NULL,
232 + "address_book",
233 + "ad.address_book_client_sessions",
234 + "Address book client sessions",
235 + "sessions",
236 + PLUGIN_WINDOWS_NAME,
237 + "PerflibAD",
238 + PRIO_AD_ADDRESS_BOOK_CLIENT_SESSIONS,
239 + update_every,
240 + RRDSET_TYPE_LINE);
241 +
242 + rd_address_book_client_sessions =
243 + rrddim_add(st_address_book_client_sessions, "sessions", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
244 + }
245 +
246 + rrddim_set_by_pointer(
247 + st_address_book_client_sessions,
248 + rd_address_book_client_sessions,
249 + (collected_number)addressBookClientSessions.current.Data);
250 + rrdset_done(st_address_book_client_sessions);
251 +}
252 +
253 +static void netdata_ad_address_book(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
254 +{
255 + netdata_ad_address_book_ambiguous_name_resolution(pDataBlock, pObjectType, update_every);
256 + netdata_ad_address_book_browse(pDataBlock, pObjectType, update_every);
257 + netdata_ad_address_book_find(pDataBlock, pObjectType, update_every);
258 + netdata_ad_address_book_property_read(pDataBlock, pObjectType, update_every);
259 + netdata_ad_address_book_search(pDataBlock, pObjectType, update_every);
260 + netdata_ad_address_book_proxy_search(pDataBlock, pObjectType, update_every);
261 + netdata_ad_address_book_client_sessions(pDataBlock, pObjectType, update_every);
262 +}
263 +
264 +static void
265 +netdata_ad_approximate_highest_dnt(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
266 +{
267 + static COUNTER_DATA approximateHighestDNT = {.key = "Approximate highest DNT"};
268 +
269 + static RRDSET *st_approximate_highest_dnt = NULL;
270 + static RRDDIM *rd_approximate_highest_dnt = NULL;
271 +
272 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &approximateHighestDNT))
273 + return;
274 +
275 + if (unlikely(!st_approximate_highest_dnt)) {
276 + st_approximate_highest_dnt = rrdset_create_localhost(
277 + "ad",
278 + "approximate_highest_dnt",
279 + NULL,
280 + "database",
281 + "ad.approximate_highest_dnt",
282 + "Approximate highest distinguished name tag",
283 + "dnt",
284 + PLUGIN_WINDOWS_NAME,
285 + "PerflibAD",
286 + PRIO_AD_APPROXIMATE_HIGHEST_DNT,
287 + update_every,
288 + RRDSET_TYPE_LINE);
289 +
290 + rd_approximate_highest_dnt = rrddim_add(st_approximate_highest_dnt, "dnt", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
291 + }
292 +
293 + rrddim_set_by_pointer(
294 + st_approximate_highest_dnt, rd_approximate_highest_dnt, (collected_number)approximateHighestDNT.current.Data);
295 + rrdset_done(st_approximate_highest_dnt);
296 +}
297 +
298 static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
299 {
300 static COUNTER_DATA directoryPercReadsFromDCA = {.key = "DS % Reads from DRA"};
@@ -11,7 +303,7 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
303 static COUNTER_DATA directoryPercReadsFromNSPI = {.key = "DS % Reads from NSPI"};
304 static COUNTER_DATA directoryPercReadsFromNTDSAPI = {.key = "DS % Reads from NTDSAPI"};
305 static COUNTER_DATA directoryPercReadsFromSAM = {.key = "DS % Reads from SAM"};
14 - static COUNTER_DATA directoryPercReadsOther = {.key = "DS % Reads from Other"};
306 + static COUNTER_DATA directoryPercReadsOther = {.key = "DS % Reads Other"};
307
308 static COUNTER_DATA directoryPercSearchesFromDCA = {.key = "DS % Searches from DRA"};
309 static COUNTER_DATA directoryPercSearchesFromKCC = {.key = "DS % Searches from KCC"};
@@ -19,7 +311,8 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
311 static COUNTER_DATA directoryPercSearchesFromNSPI = {.key = "DS % Searches from NSPI"};
312 static COUNTER_DATA directoryPercSearchesFromNTDSAPI = {.key = "DS % Searches from NTDSAPI"};
313 static COUNTER_DATA directoryPercSearchesFromSAM = {.key = "DS % Searches from SAM"};
22 - static COUNTER_DATA directoryPercSearchesOther = {.key = "DS % Searches from Other"};
314 + static COUNTER_DATA directoryPercSearchesFromLDAP = {.key = "DS % Searches from LDAP"};
315 + static COUNTER_DATA directoryPercSearchesOther = {.key = "DS % Searches Other"};
316
317 static COUNTER_DATA directoryPercWritesFromDCA = {.key = "DS % Writes from DRA"};
318 static COUNTER_DATA directoryPercWritesFromKCC = {.key = "DS % Writes from KCC"};
@@ -27,7 +320,8 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
320 static COUNTER_DATA directoryPercWritesFromNSPI = {.key = "DS % Writes from NSPI"};
321 static COUNTER_DATA directoryPercWritesFromNTDSAPI = {.key = "DS % Writes from NTDSAPI"};
322 static COUNTER_DATA directoryPercWritesFromSAM = {.key = "DS % Writes from SAM"};
30 - static COUNTER_DATA directoryPercWritesOther = {.key = "DS % Writes from Other"};
323 + static COUNTER_DATA directoryPercWritesFromLDAP = {.key = "DS % Writes from LDAP"};
324 + static COUNTER_DATA directoryPercWritesOther = {.key = "DS % Writes Other"};
325
326 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercReadsFromDCA);
327 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercReadsFromKCC);
@@ -43,6 +337,7 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
337 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercSearchesFromNSPI);
338 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercSearchesFromNTDSAPI);
339 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercSearchesFromSAM);
340 + perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercSearchesFromLDAP);
341 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercSearchesOther);
342
343 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercWritesFromDCA);
@@ -51,6 +346,7 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
346 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercWritesFromNSPI);
347 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercWritesFromNTDSAPI);
348 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercWritesFromSAM);
349 + perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercWritesFromLDAP);
350 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercWritesOther);
351
352 static RRDSET *st_directory_operation_total = NULL;
@@ -90,13 +386,14 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
386 collected_number writeValue = directoryPercWritesFromDCA.current.Data + directoryPercWritesFromKCC.current.Data +
387 directoryPercWritesFromLSA.current.Data + directoryPercWritesFromNSPI.current.Data +
388 directoryPercWritesFromNTDSAPI.current.Data +
93 - directoryPercWritesFromSAM.current.Data + directoryPercWritesOther.current.Data;
389 + directoryPercWritesFromSAM.current.Data + directoryPercWritesFromLDAP.current.Data +
390 + directoryPercWritesOther.current.Data;
391
392 collected_number searchValue =
393 directoryPercSearchesFromDCA.current.Data + directoryPercSearchesFromKCC.current.Data +
394 directoryPercSearchesFromLSA.current.Data + directoryPercSearchesFromNSPI.current.Data +
395 directoryPercSearchesFromNTDSAPI.current.Data + directoryPercSearchesFromSAM.current.Data +
99 - directoryPercSearchesOther.current.Data;
396 + directoryPercSearchesFromLDAP.current.Data + directoryPercSearchesOther.current.Data;
397
398 rrddim_set_by_pointer(st_directory_operation_total, rd_directory_operation_total_read, readValue);
399
@@ -107,9 +404,115 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
404 rrdset_done(st_directory_operation_total);
405 }
406
407 +static void netdata_ad_search_scope_base(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
408 +{
409 + static COUNTER_DATA baseSearchesPerSec = {.key = "Base searches/sec"};
410 + static RRDSET *st_search_scope_base = NULL;
411 + static RRDDIM *rd_search_scope_base = NULL;
412 +
413 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &baseSearchesPerSec))
414 + return;
415 +
416 + if (unlikely(!st_search_scope_base)) {
417 + st_search_scope_base = rrdset_create_localhost(
418 + "ad",
419 + "searches_base",
420 + NULL,
421 + "search",
422 + "ad.searches_base",
423 + "Directory base searches",
424 + "searches/s",
425 + PLUGIN_WINDOWS_NAME,
426 + "PerflibAD",
427 + PRIO_AD_SEARCHES_SCOPE_BASE,
428 + update_every,
429 + RRDSET_TYPE_LINE);
430 +
431 + rd_search_scope_base = rrddim_add(st_search_scope_base, "base", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
432 + }
433 +
434 + rrddim_set_by_pointer(
435 + st_search_scope_base, rd_search_scope_base, (collected_number)baseSearchesPerSec.current.Data);
436 + rrdset_done(st_search_scope_base);
437 +}
438 +
439 +static void
440 +netdata_ad_search_scope_subtree(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
441 +{
442 + static COUNTER_DATA subtreeSearchesPerSec = {.key = "Subtree searches/sec"};
443 + static RRDSET *st_search_scope_subtree = NULL;
444 + static RRDDIM *rd_search_scope_subtree = NULL;
445 +
446 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &subtreeSearchesPerSec))
447 + return;
448 +
449 + if (unlikely(!st_search_scope_subtree)) {
450 + st_search_scope_subtree = rrdset_create_localhost(
451 + "ad",
452 + "searches_subtree",
453 + NULL,
454 + "search",
455 + "ad.searches_subtree",
456 + "Directory subtree searches",
457 + "searches/s",
458 + PLUGIN_WINDOWS_NAME,
459 + "PerflibAD",
460 + PRIO_AD_SEARCHES_SCOPE_SUBTREE,
461 + update_every,
462 + RRDSET_TYPE_LINE);
463 +
464 + rd_search_scope_subtree = rrddim_add(st_search_scope_subtree, "subtree", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
465 + }
466 +
467 + rrddim_set_by_pointer(
468 + st_search_scope_subtree, rd_search_scope_subtree, (collected_number)subtreeSearchesPerSec.current.Data);
469 + rrdset_done(st_search_scope_subtree);
470 +}
471 +
472 +static void
473 +netdata_ad_search_scope_one_level(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
474 +{
475 + static COUNTER_DATA oneLevelSearchesPerSec = {.key = "Onelevel searches/sec"};
476 + static RRDSET *st_search_scope_one_level = NULL;
477 + static RRDDIM *rd_search_scope_one_level = NULL;
478 +
479 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &oneLevelSearchesPerSec))
480 + return;
481 +
482 + if (unlikely(!st_search_scope_one_level)) {
483 + st_search_scope_one_level = rrdset_create_localhost(
484 + "ad",
485 + "searches_one_level",
486 + NULL,
487 + "search",
488 + "ad.searches_one_level",
489 + "Directory one-level searches",
490 + "searches/s",
491 + PLUGIN_WINDOWS_NAME,
492 + "PerflibAD",
493 + PRIO_AD_SEARCHES_SCOPE_ONE_LEVEL,
494 + update_every,
495 + RRDSET_TYPE_LINE);
496 +
497 + rd_search_scope_one_level =
498 + rrddim_add(st_search_scope_one_level, "one_level", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
499 + }
500 +
501 + rrddim_set_by_pointer(
502 + st_search_scope_one_level, rd_search_scope_one_level, (collected_number)oneLevelSearchesPerSec.current.Data);
503 + rrdset_done(st_search_scope_one_level);
504 +}
505 +
506 +static void netdata_ad_search_scope(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
507 +{
508 + netdata_ad_search_scope_base(pDataBlock, pObjectType, update_every);
509 + netdata_ad_search_scope_subtree(pDataBlock, pObjectType, update_every);
510 + netdata_ad_search_scope_one_level(pDataBlock, pObjectType, update_every);
511 +}
512 +
513 static void netdata_ad_cache_lookups(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
514 {
112 - static COUNTER_DATA nameCacheLookupsTotal = {.key = "DS Name Cache hit rate,secondvalue"};
515 + static COUNTER_DATA nameCacheLookupsTotal = {.key = "DS Name Cache hit rate"};
516
517 static RRDSET *st_name_cache_lookups_total = NULL;
518 static RRDDIM *rd_name_cache_lookups_total = NULL;
@@ -144,7 +547,7 @@ static void netdata_ad_cache_lookups(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TY
547
548 static void netdata_ad_cache_hits(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
549 {
147 - static COUNTER_DATA nameCacheHitsTotal = {.key = "DS Name Cache hit rate"};
550 + static COUNTER_DATA nameCacheHitsTotal = {.key = "DS Name Cache hit rate,secondvalue"};
551
552 static RRDSET *st_name_cache_hits_total = NULL;
553 static RRDDIM *rd_name_cache_hits_total = NULL;
@@ -288,7 +691,7 @@ static void netdata_ad_compressed_traffic(PERF_DATA_BLOCK *pDataBlock, PERF_OBJE
691 .key = "DRA Outbound Bytes Compressed (Between Sites, After Compression)/sec"};
692
693 static COUNTER_DATA replicationDataInboundIntraSiteBytesTotal = {
291 - .key = "DRA Inbound Bytes Compressed (Within Site, After Compression)/sec"};
694 + .key = "DRA Inbound Bytes Not Compressed (Within Site)/sec"};
695 static COUNTER_DATA replicationDataOutboundIntraSiteBytesTotal = {
696 .key = "DRA Outbound Bytes Not Compressed (Within Site)/sec"};
697
@@ -296,7 +699,7 @@ static void netdata_ad_compressed_traffic(PERF_DATA_BLOCK *pDataBlock, PERF_OBJE
699 static RRDDIM *rd_replication_data_intersite_bytes_total_inbound = NULL;
700 static RRDDIM *rd_replication_data_intersite_bytes_total_outbound = NULL;
701
299 - static RRDSET *st_dra_replication_intrasite_compressed_traffic = NULL;
702 + static RRDSET *st_dra_replication_intrasite_uncompressed_traffic = NULL;
703 static RRDDIM *rd_replication_data_intrasite_bytes_total_inbound = NULL;
704 static RRDDIM *rd_replication_data_intrasite_bytes_total_outbound = NULL;
705
@@ -343,361 +746,3059 @@ intraChart:
746 return;
747 }
748
346 - if (unlikely(!st_dra_replication_intrasite_compressed_traffic)) {
347 - st_dra_replication_intrasite_compressed_traffic = rrdset_create_localhost(
749 + if (unlikely(!st_dra_replication_intrasite_uncompressed_traffic)) {
750 + st_dra_replication_intrasite_uncompressed_traffic = rrdset_create_localhost(
751 "ad",
349 - "dra_replication_intrasite_compressed_traffic",
752 + "dra_replication_intrasite_uncompressed_traffic",
753 NULL,
754 "replication",
352 - "ad.dra_replication_intrasite_compressed_traffic",
353 - "DRA replication compressed traffic within site",
755 + "ad.dra_replication_intrasite_uncompressed_traffic",
756 + "DRA replication uncompressed traffic within site",
757 "bytes/s",
758 PLUGIN_WINDOWS_NAME,
759 "PerflibAD",
357 - PRIO_AD_REPLICATION_INTRASITE_COMPRESSED,
760 + PRIO_AD_REPLICATION_INTRASITE_UNCOMPRESSED,
761 update_every,
762 RRDSET_TYPE_AREA);
763
764 rd_replication_data_intrasite_bytes_total_inbound = rrddim_add(
362 - st_dra_replication_intrasite_compressed_traffic, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
765 + st_dra_replication_intrasite_uncompressed_traffic, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
766
767 rd_replication_data_intrasite_bytes_total_outbound = rrddim_add(
365 - st_dra_replication_intrasite_compressed_traffic, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
768 + st_dra_replication_intrasite_uncompressed_traffic, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
769 }
770
771 rrddim_set_by_pointer(
369 - st_dra_replication_intrasite_compressed_traffic,
772 + st_dra_replication_intrasite_uncompressed_traffic,
773 rd_replication_data_intrasite_bytes_total_inbound,
774 (collected_number)replicationDataInboundIntraSiteBytesTotal.current.Data);
775 rrddim_set_by_pointer(
373 - st_dra_replication_intrasite_compressed_traffic,
776 + st_dra_replication_intrasite_uncompressed_traffic,
777 rd_replication_data_intrasite_bytes_total_outbound,
778 (collected_number)replicationDataOutboundIntraSiteBytesTotal.current.Data);
376 - rrdset_done(st_dra_replication_intrasite_compressed_traffic);
779 + rrdset_done(st_dra_replication_intrasite_uncompressed_traffic);
780 }
781
379 -static void netdata_ad_sync(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
782 +static void netdata_ad_replication_highest_usn_committed(
783 + PERF_DATA_BLOCK *pDataBlock,
784 + PERF_OBJECT_TYPE *pObjectType,
785 + int update_every)
786 {
381 - static COUNTER_DATA replicationSyncPending = {.key = "DRA Pending Replication Synchronizations"};
382 - static COUNTER_DATA replicationSyncRequestsTotal = {.key = "DRA Sync Requests Made"};
383 -
384 - static RRDSET *st_dra_replication_pending_syncs = NULL;
385 - static RRDDIM *rd_dra_replication_pending_syncs = NULL;
386 - static RRDSET *st_dra_replication_sync_requests = NULL;
387 - static RRDDIM *rd_dra_replication_sync_requests = NULL;
787 + static COUNTER_DATA replicationHighestUSNCommittedHighPart = {.key = "DRA Highest USN Committed (High part)"};
788 + static COUNTER_DATA replicationHighestUSNCommittedLowPart = {.key = "DRA Highest USN Committed (Low part)"};
789 + static RRDSET *st_replication_highest_usn_committed = NULL;
790 + static RRDDIM *rd_replication_highest_usn_committed = NULL;
791
389 - if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationSyncPending)) {
390 - goto totalSyncChart;
391 - }
792 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationHighestUSNCommittedHighPart) ||
793 + !perflibGetObjectCounter(pDataBlock, pObjectType, &replicationHighestUSNCommittedLowPart))
794 + return;
795
393 - if (unlikely(!st_dra_replication_pending_syncs)) {
394 - st_dra_replication_pending_syncs = rrdset_create_localhost(
796 + if (unlikely(!st_replication_highest_usn_committed)) {
797 + st_replication_highest_usn_committed = rrdset_create_localhost(
798 "ad",
396 - "dra_replication_pending_syncs",
799 + "replication_highest_usn_committed",
800 NULL,
801 "replication",
399 - "ad.dra_replication_pending_syncs",
400 - "DRA replication pending syncs",
401 - "syncs",
802 + "ad.replication_highest_usn_committed",
803 + "Highest replication committed update sequence number",
804 + "usn/s",
805 PLUGIN_WINDOWS_NAME,
806 "PerflibAD",
404 - PRIO_AD_SYNC_PENDING,
807 + PRIO_AD_REPLICATION_HIGHEST_USN_COMMITTED,
808 update_every,
809 RRDSET_TYPE_LINE);
810
408 - rd_dra_replication_pending_syncs =
409 - rrddim_add(st_dra_replication_pending_syncs, "pending", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
811 + rd_replication_highest_usn_committed =
812 + rrddim_add(st_replication_highest_usn_committed, "committed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
813 }
814
815 + // Windows exposes the 64-bit USN as separate high/low perf counters.
816 + uint64_t committed = ((uint64_t)replicationHighestUSNCommittedHighPart.current.Data << 32) |
817 + (uint64_t)replicationHighestUSNCommittedLowPart.current.Data;
818 +
819 rrddim_set_by_pointer(
413 - st_dra_replication_pending_syncs,
414 - rd_dra_replication_pending_syncs,
415 - (collected_number)replicationSyncPending.current.Data);
416 - rrdset_done(st_dra_replication_pending_syncs);
820 + st_replication_highest_usn_committed, rd_replication_highest_usn_committed, (collected_number)committed);
821 + rrdset_done(st_replication_highest_usn_committed);
822 +}
823
418 -totalSyncChart:
419 - if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationSyncRequestsTotal)) {
824 +static void
825 +netdata_ad_replication_highest_usn_issued(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
826 +{
827 + static COUNTER_DATA replicationHighestUSNIssuedHighPart = {.key = "DRA Highest USN Issued (High part)"};
828 + static COUNTER_DATA replicationHighestUSNIssuedLowPart = {.key = "DRA Highest USN Issued (Low part)"};
829 + static RRDSET *st_replication_highest_usn_issued = NULL;
830 + static RRDDIM *rd_replication_highest_usn_issued = NULL;
831 +
832 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationHighestUSNIssuedHighPart) ||
833 + !perflibGetObjectCounter(pDataBlock, pObjectType, &replicationHighestUSNIssuedLowPart))
834 return;
421 - }
835
423 - if (unlikely(!st_dra_replication_sync_requests)) {
424 - st_dra_replication_sync_requests = rrdset_create_localhost(
836 + if (unlikely(!st_replication_highest_usn_issued)) {
837 + st_replication_highest_usn_issued = rrdset_create_localhost(
838 "ad",
426 - "dra_replication_sync_requests",
839 + "replication_highest_usn_issued",
840 NULL,
841 "replication",
429 - "ad.dra_replication_sync_requests",
430 - "DRA replication sync requests",
431 - "requests/s",
842 + "ad.replication_highest_usn_issued",
843 + "Highest replication issued update sequence number",
844 + "usn/s",
845 PLUGIN_WINDOWS_NAME,
846 "PerflibAD",
434 - PRIO_AD_SYNC_TOTAL,
847 + PRIO_AD_REPLICATION_HIGHEST_USN_ISSUED,
848 update_every,
849 RRDSET_TYPE_LINE);
850
438 - rd_dra_replication_sync_requests =
439 - rrddim_add(st_dra_replication_sync_requests, "request", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
851 + rd_replication_highest_usn_issued =
852 + rrddim_add(st_replication_highest_usn_issued, "issued", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
853 }
854
855 + // Windows exposes the 64-bit USN as separate high/low perf counters.
856 + uint64_t issued = ((uint64_t)replicationHighestUSNIssuedHighPart.current.Data << 32) |
857 + (uint64_t)replicationHighestUSNIssuedLowPart.current.Data;
858 +
859 rrddim_set_by_pointer(
443 - st_dra_replication_sync_requests,
444 - rd_dra_replication_sync_requests,
445 - (collected_number)replicationSyncRequestsTotal.current.Data);
446 - rrdset_done(st_dra_replication_sync_requests);
860 + st_replication_highest_usn_issued, rd_replication_highest_usn_issued, (collected_number)issued);
861 + rrdset_done(st_replication_highest_usn_issued);
862 }
863
864 static void
450 -netdata_ad_service_threads_in_use(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
865 +netdata_ad_replication_highest_usn(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
866 {
452 - static COUNTER_DATA directoryServiceThreads = {.key = "DS Threads in Use"};
867 + netdata_ad_replication_highest_usn_committed(pDataBlock, pObjectType, update_every);
868 + netdata_ad_replication_highest_usn_issued(pDataBlock, pObjectType, update_every);
869 +}
870
454 - static RRDSET *st_directory_services_threads = NULL;
455 - static RRDDIM *rd_directory_services_threads = NULL;
871 +static void netdata_ad_replication_inbound_sync_objects_remaining(
872 + PERF_DATA_BLOCK *pDataBlock,
873 + PERF_OBJECT_TYPE *pObjectType,
874 + int update_every)
875 +{
876 + static COUNTER_DATA replicationInboundSyncObjectsRemaining = {.key = "DRA Inbound Full Sync Objects Remaining"};
877 + static RRDSET *st_replication_inbound_sync_objects_remaining = NULL;
878 + static RRDDIM *rd_replication_inbound_sync_objects_remaining = NULL;
879
457 - if (!perflibGetObjectCounter(pDataBlock, pObjectType, &directoryServiceThreads)) {
880 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundSyncObjectsRemaining))
881 return;
459 - }
882
461 - if (unlikely(!st_directory_services_threads)) {
883 + if (unlikely(!st_replication_inbound_sync_objects_remaining)) {
884 + st_replication_inbound_sync_objects_remaining = rrdset_create_localhost(
885 + "ad",
886 + "replication_inbound_sync_objects_remaining",
887 + NULL,
888 + "replication",
889 + "ad.replication_inbound_sync_objects_remaining",
890 + "Replication inbound sync objects remaining",
891 + "objects",
892 + PLUGIN_WINDOWS_NAME,
893 + "PerflibAD",
894 + PRIO_AD_REPLICATION_INBOUND_SYNC_OBJECTS_REMAINING,
895 + update_every,
896 + RRDSET_TYPE_LINE);
897 +
898 + rd_replication_inbound_sync_objects_remaining =
899 + rrddim_add(st_replication_inbound_sync_objects_remaining, "remaining", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
900 + }
901 +
902 + rrddim_set_by_pointer(
903 + st_replication_inbound_sync_objects_remaining,
904 + rd_replication_inbound_sync_objects_remaining,
905 + (collected_number)replicationInboundSyncObjectsRemaining.current.Data);
906 + rrdset_done(st_replication_inbound_sync_objects_remaining);
907 +}
908 +
909 +static void netdata_ad_replication_inbound_link_value_updates_remaining(
910 + PERF_DATA_BLOCK *pDataBlock,
911 + PERF_OBJECT_TYPE *pObjectType,
912 + int update_every)
913 +{
914 + static COUNTER_DATA replicationInboundLinkValueUpdatesRemaining = {
915 + .key = "DRA Inbound Link Value Updates Remaining in Packet"};
916 + static RRDSET *st_replication_inbound_link_value_updates_remaining = NULL;
917 + static RRDDIM *rd_replication_inbound_link_value_updates_remaining = NULL;
918 +
919 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundLinkValueUpdatesRemaining))
920 + return;
921 +
922 + if (unlikely(!st_replication_inbound_link_value_updates_remaining)) {
923 + st_replication_inbound_link_value_updates_remaining = rrdset_create_localhost(
924 + "ad",
925 + "replication_inbound_link_value_updates_remaining",
926 + NULL,
927 + "replication",
928 + "ad.replication_inbound_link_value_updates_remaining",
929 + "Replication inbound link value updates remaining",
930 + "updates",
931 + PLUGIN_WINDOWS_NAME,
932 + "PerflibAD",
933 + PRIO_AD_REPLICATION_INBOUND_LINK_VALUE_UPDATES_REMAINING,
934 + update_every,
935 + RRDSET_TYPE_LINE);
936 +
937 + rd_replication_inbound_link_value_updates_remaining = rrddim_add(
938 + st_replication_inbound_link_value_updates_remaining, "remaining", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
939 + }
940 +
941 + rrddim_set_by_pointer(
942 + st_replication_inbound_link_value_updates_remaining,
943 + rd_replication_inbound_link_value_updates_remaining,
944 + (collected_number)replicationInboundLinkValueUpdatesRemaining.current.Data);
945 + rrdset_done(st_replication_inbound_link_value_updates_remaining);
946 +}
947 +
948 +static void netdata_ad_replication_inbound_objects_updated(
949 + PERF_DATA_BLOCK *pDataBlock,
950 + PERF_OBJECT_TYPE *pObjectType,
951 + int update_every)
952 +{
953 + static COUNTER_DATA replicationInboundObjectsUpdatedTotal = {.key = "DRA Inbound Objects Applied/sec"};
954 + static RRDSET *st_replication_inbound_objects_updated = NULL;
955 + static RRDDIM *rd_replication_inbound_objects_updated = NULL;
956 +
957 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundObjectsUpdatedTotal))
958 + return;
959 +
960 + if (unlikely(!st_replication_inbound_objects_updated)) {
961 + st_replication_inbound_objects_updated = rrdset_create_localhost(
962 + "ad",
963 + "replication_inbound_objects_updated",
964 + NULL,
965 + "replication",
966 + "ad.replication_inbound_objects_updated",
967 + "Replication inbound objects updated",
968 + "objects/s",
969 + PLUGIN_WINDOWS_NAME,
970 + "PerflibAD",
971 + PRIO_AD_REPLICATION_INBOUND_OBJECTS_UPDATED,
972 + update_every,
973 + RRDSET_TYPE_LINE);
974 +
975 + rd_replication_inbound_objects_updated =
976 + rrddim_add(st_replication_inbound_objects_updated, "updated", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
977 + }
978 +
979 + rrddim_set_by_pointer(
980 + st_replication_inbound_objects_updated,
981 + rd_replication_inbound_objects_updated,
982 + (collected_number)replicationInboundObjectsUpdatedTotal.current.Data);
983 + rrdset_done(st_replication_inbound_objects_updated);
984 +}
985 +
986 +static void netdata_ad_replication_inbound_objects_filtered(
987 + PERF_DATA_BLOCK *pDataBlock,
988 + PERF_OBJECT_TYPE *pObjectType,
989 + int update_every)
990 +{
991 + static COUNTER_DATA replicationInboundObjectsFilteredTotal = {.key = "DRA Inbound Objects Filtered/sec"};
992 + static RRDSET *st_replication_inbound_objects_filtered = NULL;
993 + static RRDDIM *rd_replication_inbound_objects_filtered = NULL;
994 +
995 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundObjectsFilteredTotal))
996 + return;
997 +
998 + if (unlikely(!st_replication_inbound_objects_filtered)) {
999 + st_replication_inbound_objects_filtered = rrdset_create_localhost(
1000 + "ad",
1001 + "replication_inbound_objects_filtered",
1002 + NULL,
1003 + "replication",
1004 + "ad.replication_inbound_objects_filtered",
1005 + "Replication inbound objects filtered",
1006 + "objects/s",
1007 + PLUGIN_WINDOWS_NAME,
1008 + "PerflibAD",
1009 + PRIO_AD_REPLICATION_INBOUND_OBJECTS_FILTERED,
1010 + update_every,
1011 + RRDSET_TYPE_LINE);
1012 +
1013 + rd_replication_inbound_objects_filtered =
1014 + rrddim_add(st_replication_inbound_objects_filtered, "filtered", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1015 + }
1016 +
1017 + rrddim_set_by_pointer(
1018 + st_replication_inbound_objects_filtered,
1019 + rd_replication_inbound_objects_filtered,
1020 + (collected_number)replicationInboundObjectsFilteredTotal.current.Data);
1021 + rrdset_done(st_replication_inbound_objects_filtered);
1022 +}
1023 +
1024 +static void netdata_ad_replication_inbound(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1025 +{
1026 + netdata_ad_replication_inbound_sync_objects_remaining(pDataBlock, pObjectType, update_every);
1027 + netdata_ad_replication_inbound_link_value_updates_remaining(pDataBlock, pObjectType, update_every);
1028 + netdata_ad_replication_inbound_objects_updated(pDataBlock, pObjectType, update_every);
1029 + netdata_ad_replication_inbound_objects_filtered(pDataBlock, pObjectType, update_every);
1030 +}
1031 +
1032 +static void netdata_ad_sync(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1033 +{
1034 + static COUNTER_DATA replicationSyncPending = {.key = "DRA Pending Replication Synchronizations"};
1035 + static COUNTER_DATA replicationSyncRequestsTotal = {.key = "DRA Sync Requests Made"};
1036 +
1037 + static RRDSET *st_dra_replication_pending_syncs = NULL;
1038 + static RRDDIM *rd_dra_replication_pending_syncs = NULL;
1039 + static RRDSET *st_dra_replication_sync_requests = NULL;
1040 + static RRDDIM *rd_dra_replication_sync_requests = NULL;
1041 +
1042 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationSyncPending)) {
1043 + goto totalSyncChart;
1044 + }
1045 +
1046 + if (unlikely(!st_dra_replication_pending_syncs)) {
1047 + st_dra_replication_pending_syncs = rrdset_create_localhost(
1048 + "ad",
1049 + "dra_replication_pending_syncs",
1050 + NULL,
1051 + "replication",
1052 + "ad.dra_replication_pending_syncs",
1053 + "DRA replication pending syncs",
1054 + "syncs",
1055 + PLUGIN_WINDOWS_NAME,
1056 + "PerflibAD",
1057 + PRIO_AD_SYNC_PENDING,
1058 + update_every,
1059 + RRDSET_TYPE_LINE);
1060 +
1061 + rd_dra_replication_pending_syncs =
1062 + rrddim_add(st_dra_replication_pending_syncs, "pending", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1063 + }
1064 +
1065 + rrddim_set_by_pointer(
1066 + st_dra_replication_pending_syncs,
1067 + rd_dra_replication_pending_syncs,
1068 + (collected_number)replicationSyncPending.current.Data);
1069 + rrdset_done(st_dra_replication_pending_syncs);
1070 +
1071 +totalSyncChart:
1072 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationSyncRequestsTotal)) {
1073 + return;
1074 + }
1075 +
1076 + if (unlikely(!st_dra_replication_sync_requests)) {
1077 + st_dra_replication_sync_requests = rrdset_create_localhost(
1078 + "ad",
1079 + "dra_replication_sync_requests",
1080 + NULL,
1081 + "replication",
1082 + "ad.dra_replication_sync_requests",
1083 + "DRA replication sync requests",
1084 + "requests/s",
1085 + PLUGIN_WINDOWS_NAME,
1086 + "PerflibAD",
1087 + PRIO_AD_SYNC_TOTAL,
1088 + update_every,
1089 + RRDSET_TYPE_LINE);
1090 +
1091 + rd_dra_replication_sync_requests =
1092 + rrddim_add(st_dra_replication_sync_requests, "request", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1093 + }
1094 +
1095 + rrddim_set_by_pointer(
1096 + st_dra_replication_sync_requests,
1097 + rd_dra_replication_sync_requests,
1098 + (collected_number)replicationSyncRequestsTotal.current.Data);
1099 + rrdset_done(st_dra_replication_sync_requests);
1100 +}
1101 +
1102 +static void
1103 +netdata_ad_replication_pending_operations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1104 +{
1105 + static COUNTER_DATA replicationPendingOperations = {.key = "DRA Pending Replication Operations"};
1106 +
1107 + static RRDSET *st_replication_pending_operations = NULL;
1108 + static RRDDIM *rd_replication_pending_operations = NULL;
1109 +
1110 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationPendingOperations))
1111 + return;
1112 +
1113 + if (unlikely(!st_replication_pending_operations)) {
1114 + st_replication_pending_operations = rrdset_create_localhost(
1115 + "ad",
1116 + "replication_pending_operations",
1117 + NULL,
1118 + "replication",
1119 + "ad.replication_pending_operations",
1120 + "Replication pending operations",
1121 + "operations",
1122 + PLUGIN_WINDOWS_NAME,
1123 + "PerflibAD",
1124 + PRIO_AD_REPLICATION_PENDING_OPERATIONS,
1125 + update_every,
1126 + RRDSET_TYPE_LINE);
1127 +
1128 + rd_replication_pending_operations =
1129 + rrddim_add(st_replication_pending_operations, "pending", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1130 + }
1131 +
1132 + rrddim_set_by_pointer(
1133 + st_replication_pending_operations,
1134 + rd_replication_pending_operations,
1135 + (collected_number)replicationPendingOperations.current.Data);
1136 + rrdset_done(st_replication_pending_operations);
1137 +}
1138 +
1139 +static void netdata_ad_sync_result_success(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1140 +{
1141 + static COUNTER_DATA replicationSyncRequestsSuccessTotal = {.key = "DRA Sync Requests Successful"};
1142 + static RRDSET *st_replication_sync_requests_success = NULL;
1143 + static RRDDIM *rd_replication_sync_requests_success = NULL;
1144 +
1145 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationSyncRequestsSuccessTotal))
1146 + return;
1147 +
1148 + if (unlikely(!st_replication_sync_requests_success)) {
1149 + st_replication_sync_requests_success = rrdset_create_localhost(
1150 + "ad",
1151 + "replication_sync_requests_success",
1152 + NULL,
1153 + "replication",
1154 + "ad.replication_sync_requests_success",
1155 + "Replication sync requests successful",
1156 + "requests/s",
1157 + PLUGIN_WINDOWS_NAME,
1158 + "PerflibAD",
1159 + PRIO_AD_SYNC_SUCCESS_TOTAL,
1160 + update_every,
1161 + RRDSET_TYPE_LINE);
1162 +
1163 + rd_replication_sync_requests_success =
1164 + rrddim_add(st_replication_sync_requests_success, "success", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1165 + }
1166 +
1167 + rrddim_set_by_pointer(
1168 + st_replication_sync_requests_success,
1169 + rd_replication_sync_requests_success,
1170 + (collected_number)replicationSyncRequestsSuccessTotal.current.Data);
1171 + rrdset_done(st_replication_sync_requests_success);
1172 +}
1173 +
1174 +static void netdata_ad_sync_result_schema_mismatch_failure(
1175 + PERF_DATA_BLOCK *pDataBlock,
1176 + PERF_OBJECT_TYPE *pObjectType,
1177 + int update_every)
1178 +{
1179 + static COUNTER_DATA replicationSyncRequestsSchemaMismatchFailureTotal = {
1180 + .key = "DRA Sync Failures on Schema Mismatch"};
1181 + static RRDSET *st_replication_sync_requests_schema_mismatch_failure = NULL;
1182 + static RRDDIM *rd_replication_sync_requests_schema_mismatch_failure = NULL;
1183 +
1184 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationSyncRequestsSchemaMismatchFailureTotal))
1185 + return;
1186 +
1187 + if (unlikely(!st_replication_sync_requests_schema_mismatch_failure)) {
1188 + st_replication_sync_requests_schema_mismatch_failure = rrdset_create_localhost(
1189 + "ad",
1190 + "replication_sync_requests_schema_mismatch_failure",
1191 + NULL,
1192 + "replication",
1193 + "ad.replication_sync_requests_schema_mismatch_failure",
1194 + "Replication sync requests failed due to schema mismatch",
1195 + "requests/s",
1196 + PLUGIN_WINDOWS_NAME,
1197 + "PerflibAD",
1198 + PRIO_AD_SYNC_SCHEMA_MISMATCH_FAILURE_TOTAL,
1199 + update_every,
1200 + RRDSET_TYPE_LINE);
1201 +
1202 + rd_replication_sync_requests_schema_mismatch_failure = rrddim_add(
1203 + st_replication_sync_requests_schema_mismatch_failure, "failure", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1204 + }
1205 +
1206 + rrddim_set_by_pointer(
1207 + st_replication_sync_requests_schema_mismatch_failure,
1208 + rd_replication_sync_requests_schema_mismatch_failure,
1209 + (collected_number)replicationSyncRequestsSchemaMismatchFailureTotal.current.Data);
1210 + rrdset_done(st_replication_sync_requests_schema_mismatch_failure);
1211 +}
1212 +
1213 +static void netdata_ad_sync_result(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1214 +{
1215 + netdata_ad_sync_result_success(pDataBlock, pObjectType, update_every);
1216 + netdata_ad_sync_result_schema_mismatch_failure(pDataBlock, pObjectType, update_every);
1217 +}
1218 +
1219 +static void
1220 +netdata_ad_name_translations_client(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1221 +{
1222 + static COUNTER_DATA clientNameTranslationsPerSec = {.key = "DS Client Name Translations/sec"};
1223 + static RRDSET *st_name_translations_client = NULL;
1224 + static RRDDIM *rd_name_translations_client = NULL;
1225 +
1226 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &clientNameTranslationsPerSec))
1227 + return;
1228 +
1229 + if (unlikely(!st_name_translations_client)) {
1230 + st_name_translations_client = rrdset_create_localhost(
1231 + "ad",
1232 + "name_translations_client",
1233 + NULL,
1234 + "directory",
1235 + "ad.name_translations_client",
1236 + "Client name translations",
1237 + "translations/s",
1238 + PLUGIN_WINDOWS_NAME,
1239 + "PerflibAD",
1240 + PRIO_AD_NAME_TRANSLATIONS_CLIENT,
1241 + update_every,
1242 + RRDSET_TYPE_LINE);
1243 +
1244 + rd_name_translations_client =
1245 + rrddim_add(st_name_translations_client, "client", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1246 + }
1247 +
1248 + rrddim_set_by_pointer(
1249 + st_name_translations_client,
1250 + rd_name_translations_client,
1251 + (collected_number)clientNameTranslationsPerSec.current.Data);
1252 + rrdset_done(st_name_translations_client);
1253 +}
1254 +
1255 +static void
1256 +netdata_ad_name_translations_server(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1257 +{
1258 + static COUNTER_DATA serverNameTranslationsPerSec = {.key = "DS Server Name Translations/sec"};
1259 + static RRDSET *st_name_translations_server = NULL;
1260 + static RRDDIM *rd_name_translations_server = NULL;
1261 +
1262 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &serverNameTranslationsPerSec))
1263 + return;
1264 +
1265 + if (unlikely(!st_name_translations_server)) {
1266 + st_name_translations_server = rrdset_create_localhost(
1267 + "ad",
1268 + "name_translations_server",
1269 + NULL,
1270 + "directory",
1271 + "ad.name_translations_server",
1272 + "Server name translations",
1273 + "translations/s",
1274 + PLUGIN_WINDOWS_NAME,
1275 + "PerflibAD",
1276 + PRIO_AD_NAME_TRANSLATIONS_SERVER,
1277 + update_every,
1278 + RRDSET_TYPE_LINE);
1279 +
1280 + rd_name_translations_server =
1281 + rrddim_add(st_name_translations_server, "server", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1282 + }
1283 +
1284 + rrddim_set_by_pointer(
1285 + st_name_translations_server,
1286 + rd_name_translations_server,
1287 + (collected_number)serverNameTranslationsPerSec.current.Data);
1288 + rrdset_done(st_name_translations_server);
1289 +}
1290 +
1291 +static void netdata_ad_name_translations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1292 +{
1293 + netdata_ad_name_translations_client(pDataBlock, pObjectType, update_every);
1294 + netdata_ad_name_translations_server(pDataBlock, pObjectType, update_every);
1295 +}
1296 +
1297 +static void
1298 +netdata_ad_change_monitors_registered(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1299 +{
1300 + static COUNTER_DATA changeMonitorsRegistered = {.key = "DS Monitor List Size"};
1301 + static RRDSET *st_change_monitors_registered = NULL;
1302 + static RRDDIM *rd_change_monitors_registered = NULL;
1303 +
1304 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &changeMonitorsRegistered))
1305 + return;
1306 +
1307 + if (unlikely(!st_change_monitors_registered)) {
1308 + st_change_monitors_registered = rrdset_create_localhost(
1309 + "ad",
1310 + "change_monitors_registered",
1311 + NULL,
1312 + "directory",
1313 + "ad.change_monitors_registered",
1314 + "Registered change monitors",
1315 + "monitors",
1316 + PLUGIN_WINDOWS_NAME,
1317 + "PerflibAD",
1318 + PRIO_AD_CHANGE_MONITORS_REGISTERED,
1319 + update_every,
1320 + RRDSET_TYPE_LINE);
1321 +
1322 + rd_change_monitors_registered =
1323 + rrddim_add(st_change_monitors_registered, "registered", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1324 + }
1325 +
1326 + rrddim_set_by_pointer(
1327 + st_change_monitors_registered,
1328 + rd_change_monitors_registered,
1329 + (collected_number)changeMonitorsRegistered.current.Data);
1330 + rrdset_done(st_change_monitors_registered);
1331 +}
1332 +
1333 +static void
1334 +netdata_ad_change_monitor_updates_pending(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1335 +{
1336 + static COUNTER_DATA changeMonitorUpdatesPending = {.key = "DS Notify Queue Size"};
1337 + static RRDSET *st_change_monitor_updates_pending = NULL;
1338 + static RRDDIM *rd_change_monitor_updates_pending = NULL;
1339 +
1340 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &changeMonitorUpdatesPending))
1341 + return;
1342 +
1343 + if (unlikely(!st_change_monitor_updates_pending)) {
1344 + st_change_monitor_updates_pending = rrdset_create_localhost(
1345 + "ad",
1346 + "change_monitor_updates_pending",
1347 + NULL,
1348 + "directory",
1349 + "ad.change_monitor_updates_pending",
1350 + "Pending change monitor updates",
1351 + "updates",
1352 + PLUGIN_WINDOWS_NAME,
1353 + "PerflibAD",
1354 + PRIO_AD_CHANGE_MONITOR_UPDATES_PENDING,
1355 + update_every,
1356 + RRDSET_TYPE_LINE);
1357 +
1358 + rd_change_monitor_updates_pending =
1359 + rrddim_add(st_change_monitor_updates_pending, "pending", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1360 + }
1361 +
1362 + rrddim_set_by_pointer(
1363 + st_change_monitor_updates_pending,
1364 + rd_change_monitor_updates_pending,
1365 + (collected_number)changeMonitorUpdatesPending.current.Data);
1366 + rrdset_done(st_change_monitor_updates_pending);
1367 +}
1368 +
1369 +static void netdata_ad_change_monitors(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1370 +{
1371 + netdata_ad_change_monitors_registered(pDataBlock, pObjectType, update_every);
1372 + netdata_ad_change_monitor_updates_pending(pDataBlock, pObjectType, update_every);
1373 +}
1374 +
1375 +static void
1376 +netdata_ad_directory_search_suboperations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1377 +{
1378 + static COUNTER_DATA directorySearchSubOperationsPerSec = {.key = "DS Search sub-operations/sec"};
1379 +
1380 + static RRDSET *st_directory_search_suboperations_total = NULL;
1381 + static RRDDIM *rd_directory_search_suboperations_total = NULL;
1382 +
1383 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &directorySearchSubOperationsPerSec))
1384 + return;
1385 +
1386 + if (unlikely(!st_directory_search_suboperations_total)) {
1387 + st_directory_search_suboperations_total = rrdset_create_localhost(
1388 + "ad",
1389 + "directory_search_suboperations",
1390 + NULL,
1391 + "search",
1392 + "ad.directory_search_suboperations",
1393 + "Directory search suboperations",
1394 + "operations/s",
1395 + PLUGIN_WINDOWS_NAME,
1396 + "PerflibAD",
1397 + PRIO_AD_DIRECTORY_SEARCH_SUBOPERATIONS_TOTAL,
1398 + update_every,
1399 + RRDSET_TYPE_LINE);
1400 +
1401 + rd_directory_search_suboperations_total =
1402 + rrddim_add(st_directory_search_suboperations_total, "suboperations", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1403 + }
1404 +
1405 + rrddim_set_by_pointer(
1406 + st_directory_search_suboperations_total,
1407 + rd_directory_search_suboperations_total,
1408 + (collected_number)directorySearchSubOperationsPerSec.current.Data);
1409 + rrdset_done(st_directory_search_suboperations_total);
1410 +}
1411 +
1412 +static void netdata_ad_security_descriptor_propagation_events(
1413 + PERF_DATA_BLOCK *pDataBlock,
1414 + PERF_OBJECT_TYPE *pObjectType,
1415 + int update_every)
1416 +{
1417 + static COUNTER_DATA securityDescriptorSubOperationsPerSec = {.key = "DS Security Descriptor sub-operations/sec"};
1418 + static RRDSET *st_security_descriptor_propagation_events = NULL;
1419 + static RRDDIM *rd_security_descriptor_propagation_events = NULL;
1420 +
1421 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &securityDescriptorSubOperationsPerSec))
1422 + return;
1423 +
1424 + if (unlikely(!st_security_descriptor_propagation_events)) {
1425 + st_security_descriptor_propagation_events = rrdset_create_localhost(
1426 + "ad",
1427 + "security_descriptor_propagation_events",
1428 + NULL,
1429 + "directory",
1430 + "ad.security_descriptor_propagation_events",
1431 + "Security descriptor propagation events",
1432 + "events/s",
1433 + PLUGIN_WINDOWS_NAME,
1434 + "PerflibAD",
1435 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_EVENTS_TOTAL,
1436 + update_every,
1437 + RRDSET_TYPE_LINE);
1438 +
1439 + rd_security_descriptor_propagation_events =
1440 + rrddim_add(st_security_descriptor_propagation_events, "events", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1441 + }
1442 +
1443 + rrddim_set_by_pointer(
1444 + st_security_descriptor_propagation_events,
1445 + rd_security_descriptor_propagation_events,
1446 + (collected_number)securityDescriptorSubOperationsPerSec.current.Data);
1447 + rrdset_done(st_security_descriptor_propagation_events);
1448 +}
1449 +
1450 +static void netdata_ad_security_descriptor_propagation_events_queued(
1451 + PERF_DATA_BLOCK *pDataBlock,
1452 + PERF_OBJECT_TYPE *pObjectType,
1453 + int update_every)
1454 +{
1455 + static COUNTER_DATA securityDescriptorPropagationsEvents = {.key = "DS Security Descriptor Propagations Events"};
1456 + static RRDSET *st_security_descriptor_propagation_events_queued = NULL;
1457 + static RRDDIM *rd_security_descriptor_propagation_events_queued = NULL;
1458 +
1459 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &securityDescriptorPropagationsEvents))
1460 + return;
1461 +
1462 + if (unlikely(!st_security_descriptor_propagation_events_queued)) {
1463 + st_security_descriptor_propagation_events_queued = rrdset_create_localhost(
1464 + "ad",
1465 + "security_descriptor_propagation_events_queued",
1466 + NULL,
1467 + "directory",
1468 + "ad.security_descriptor_propagation_events_queued",
1469 + "Security descriptor propagation events queued",
1470 + "events",
1471 + PLUGIN_WINDOWS_NAME,
1472 + "PerflibAD",
1473 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_EVENTS_QUEUED,
1474 + update_every,
1475 + RRDSET_TYPE_LINE);
1476 +
1477 + rd_security_descriptor_propagation_events_queued =
1478 + rrddim_add(st_security_descriptor_propagation_events_queued, "queued", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1479 + }
1480 +
1481 + rrddim_set_by_pointer(
1482 + st_security_descriptor_propagation_events_queued,
1483 + rd_security_descriptor_propagation_events_queued,
1484 + (collected_number)securityDescriptorPropagationsEvents.current.Data);
1485 + rrdset_done(st_security_descriptor_propagation_events_queued);
1486 +}
1487 +
1488 +static void netdata_ad_security_descriptor_propagation_access_wait(
1489 + PERF_DATA_BLOCK *pDataBlock,
1490 + PERF_OBJECT_TYPE *pObjectType,
1491 + int update_every)
1492 +{
1493 + static COUNTER_DATA securityDescriptorPropagatorAverageExclusionTime = {
1494 + .key = "DS Security Descriptor Propagator Average Exclusion Time"};
1495 + static RRDSET *st_security_descriptor_propagation_access_wait = NULL;
1496 + static RRDDIM *rd_security_descriptor_propagation_access_wait = NULL;
1497 +
1498 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &securityDescriptorPropagatorAverageExclusionTime))
1499 + return;
1500 +
1501 + if (unlikely(!st_security_descriptor_propagation_access_wait)) {
1502 + st_security_descriptor_propagation_access_wait = rrdset_create_localhost(
1503 + "ad",
1504 + "security_descriptor_propagation_access_wait",
1505 + NULL,
1506 + "directory",
1507 + "ad.security_descriptor_propagation_access_wait",
1508 + "Security descriptor propagation access wait",
1509 + "seconds",
1510 + PLUGIN_WINDOWS_NAME,
1511 + "PerflibAD",
1512 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_ACCESS_WAIT_TOTAL_SECONDS,
1513 + update_every,
1514 + RRDSET_TYPE_LINE);
1515 +
1516 + rd_security_descriptor_propagation_access_wait =
1517 + rrddim_add(st_security_descriptor_propagation_access_wait, "wait", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1518 + }
1519 +
1520 + rrddim_set_by_pointer(
1521 + st_security_descriptor_propagation_access_wait,
1522 + rd_security_descriptor_propagation_access_wait,
1523 + (collected_number)securityDescriptorPropagatorAverageExclusionTime.current.Data);
1524 + rrdset_done(st_security_descriptor_propagation_access_wait);
1525 +}
1526 +
1527 +static void netdata_ad_security_descriptor_propagation_items_queued(
1528 + PERF_DATA_BLOCK *pDataBlock,
1529 + PERF_OBJECT_TYPE *pObjectType,
1530 + int update_every)
1531 +{
1532 + static COUNTER_DATA securityDescriptorPropagatorRuntimeQueue = {
1533 + .key = "DS Security Descriptor Propagator Runtime Queue"};
1534 + static RRDSET *st_security_descriptor_propagation_items_queued = NULL;
1535 + static RRDDIM *rd_security_descriptor_propagation_items_queued = NULL;
1536 +
1537 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &securityDescriptorPropagatorRuntimeQueue))
1538 + return;
1539 +
1540 + if (unlikely(!st_security_descriptor_propagation_items_queued)) {
1541 + st_security_descriptor_propagation_items_queued = rrdset_create_localhost(
1542 + "ad",
1543 + "security_descriptor_propagation_items_queued",
1544 + NULL,
1545 + "directory",
1546 + "ad.security_descriptor_propagation_items_queued",
1547 + "Security descriptor propagation items queued",
1548 + "items",
1549 + PLUGIN_WINDOWS_NAME,
1550 + "PerflibAD",
1551 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_ITEMS_QUEUED_TOTAL,
1552 + update_every,
1553 + RRDSET_TYPE_LINE);
1554 +
1555 + rd_security_descriptor_propagation_items_queued =
1556 + rrddim_add(st_security_descriptor_propagation_items_queued, "queued", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1557 + }
1558 +
1559 + rrddim_set_by_pointer(
1560 + st_security_descriptor_propagation_items_queued,
1561 + rd_security_descriptor_propagation_items_queued,
1562 + (collected_number)securityDescriptorPropagatorRuntimeQueue.current.Data);
1563 + rrdset_done(st_security_descriptor_propagation_items_queued);
1564 +}
1565 +
1566 +static void
1567 +netdata_ad_security_descriptor_propagation(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1568 +{
1569 + netdata_ad_security_descriptor_propagation_events(pDataBlock, pObjectType, update_every);
1570 + netdata_ad_security_descriptor_propagation_events_queued(pDataBlock, pObjectType, update_every);
1571 + netdata_ad_security_descriptor_propagation_access_wait(pDataBlock, pObjectType, update_every);
1572 + netdata_ad_security_descriptor_propagation_items_queued(pDataBlock, pObjectType, update_every);
1573 +}
1574 +
1575 +static void
1576 +netdata_ad_service_threads_in_use(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1577 +{
1578 + static COUNTER_DATA directoryServiceThreads = {.key = "DS Threads in Use"};
1579 +
1580 + static RRDSET *st_directory_services_threads = NULL;
1581 + static RRDDIM *rd_directory_services_threads = NULL;
1582 +
1583 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &directoryServiceThreads)) {
1584 + return;
1585 + }
1586 +
1587 + if (unlikely(!st_directory_services_threads)) {
1588 st_directory_services_threads = rrdset_create_localhost(
1589 "ad",
464 - "ds_threads",
1590 + "ds_threads",
1591 + NULL,
1592 + "threads",
1593 + "ad.ds_threads",
1594 + "Directory Service threads",
1595 + "threads",
1596 + PLUGIN_WINDOWS_NAME,
1597 + "PerflibAD",
1598 + PRIO_AD_THREADS_IN_USE,
1599 + update_every,
1600 + RRDSET_TYPE_LINE);
1601 +
1602 + rd_directory_services_threads =
1603 + rrddim_add(st_directory_services_threads, "thread", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1604 + }
1605 +
1606 + rrddim_set_by_pointer(
1607 + st_directory_services_threads,
1608 + rd_directory_services_threads,
1609 + (collected_number)directoryServiceThreads.current.Data);
1610 + rrdset_done(st_directory_services_threads);
1611 +}
1612 +
1613 +static void netdata_ad_bind_time(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1614 +{
1615 + static COUNTER_DATA ldapLastBindTimeSecondsTotal = {.key = "LDAP Bind Time"};
1616 + static RRDSET *st_ldap_last_bind_time_seconds_total = NULL;
1617 + static RRDDIM *rd_ldap_last_bind_time_seconds_total = NULL;
1618 +
1619 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapLastBindTimeSecondsTotal)) {
1620 + return;
1621 + }
1622 +
1623 + if (unlikely(!st_ldap_last_bind_time_seconds_total)) {
1624 + st_ldap_last_bind_time_seconds_total = rrdset_create_localhost(
1625 + "ad",
1626 + "ldap_last_bind_time",
1627 + NULL,
1628 + "bind",
1629 + "ad.ldap_last_bind_time",
1630 + "LDAP last successful bind time",
1631 + "seconds",
1632 + PLUGIN_WINDOWS_NAME,
1633 + "PerflibAD",
1634 + PRIO_AD_BIND_TIME,
1635 + update_every,
1636 + RRDSET_TYPE_LINE);
1637 +
1638 + rd_ldap_last_bind_time_seconds_total =
1639 + rrddim_add(st_ldap_last_bind_time_seconds_total, "last_bind", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
1640 + }
1641 +
1642 + rrddim_set_by_pointer(
1643 + st_ldap_last_bind_time_seconds_total,
1644 + rd_ldap_last_bind_time_seconds_total,
1645 + (collected_number)ldapLastBindTimeSecondsTotal.current.Data);
1646 + rrdset_done(st_ldap_last_bind_time_seconds_total);
1647 +}
1648 +
1649 +static void netdata_ad_binds_digest(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1650 +{
1651 + static COUNTER_DATA digestBindsPerSec = {.key = "Digest Binds/sec"};
1652 + static RRDSET *st_binds_digest = NULL;
1653 + static RRDDIM *rd_binds_digest = NULL;
1654 +
1655 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &digestBindsPerSec))
1656 + return;
1657 +
1658 + if (unlikely(!st_binds_digest)) {
1659 + st_binds_digest = rrdset_create_localhost(
1660 + "ad",
1661 + "binds_digest",
1662 + NULL,
1663 + "bind",
1664 + "ad.binds_digest",
1665 + "Digest binds",
1666 + "binds/s",
1667 + PLUGIN_WINDOWS_NAME,
1668 + "PerflibAD",
1669 + PRIO_AD_BIND_DIGEST,
1670 + update_every,
1671 + RRDSET_TYPE_LINE);
1672 +
1673 + rd_binds_digest = rrddim_add(st_binds_digest, "digest", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1674 + }
1675 +
1676 + rrddim_set_by_pointer(st_binds_digest, rd_binds_digest, (collected_number)digestBindsPerSec.current.Data);
1677 + rrdset_done(st_binds_digest);
1678 +}
1679 +
1680 +static void netdata_ad_binds_ds_client(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1681 +{
1682 + static COUNTER_DATA dsClientBindsPerSec = {.key = "DS Client Binds/sec"};
1683 + static RRDSET *st_binds_ds_client = NULL;
1684 + static RRDDIM *rd_binds_ds_client = NULL;
1685 +
1686 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &dsClientBindsPerSec))
1687 + return;
1688 +
1689 + if (unlikely(!st_binds_ds_client)) {
1690 + st_binds_ds_client = rrdset_create_localhost(
1691 + "ad",
1692 + "binds_ds_client",
1693 + NULL,
1694 + "bind",
1695 + "ad.binds_ds_client",
1696 + "DS client binds",
1697 + "binds/s",
1698 + PLUGIN_WINDOWS_NAME,
1699 + "PerflibAD",
1700 + PRIO_AD_BIND_DS_CLIENT,
1701 + update_every,
1702 + RRDSET_TYPE_LINE);
1703 +
1704 + rd_binds_ds_client = rrddim_add(st_binds_ds_client, "ds_client", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1705 + }
1706 +
1707 + rrddim_set_by_pointer(st_binds_ds_client, rd_binds_ds_client, (collected_number)dsClientBindsPerSec.current.Data);
1708 + rrdset_done(st_binds_ds_client);
1709 +}
1710 +
1711 +static void netdata_ad_binds_ds_server(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1712 +{
1713 + static COUNTER_DATA dsServerBindsPerSec = {.key = "DS Server Binds/sec"};
1714 + static RRDSET *st_binds_ds_server = NULL;
1715 + static RRDDIM *rd_binds_ds_server = NULL;
1716 +
1717 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &dsServerBindsPerSec))
1718 + return;
1719 +
1720 + if (unlikely(!st_binds_ds_server)) {
1721 + st_binds_ds_server = rrdset_create_localhost(
1722 + "ad",
1723 + "binds_ds_server",
1724 + NULL,
1725 + "bind",
1726 + "ad.binds_ds_server",
1727 + "DS server binds",
1728 + "binds/s",
1729 + PLUGIN_WINDOWS_NAME,
1730 + "PerflibAD",
1731 + PRIO_AD_BIND_DS_SERVER,
1732 + update_every,
1733 + RRDSET_TYPE_LINE);
1734 +
1735 + rd_binds_ds_server = rrddim_add(st_binds_ds_server, "ds_server", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1736 + }
1737 +
1738 + rrddim_set_by_pointer(st_binds_ds_server, rd_binds_ds_server, (collected_number)dsServerBindsPerSec.current.Data);
1739 + rrdset_done(st_binds_ds_server);
1740 +}
1741 +
1742 +static void netdata_ad_binds_external(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1743 +{
1744 + static COUNTER_DATA externalBindsPerSec = {.key = "External Binds/sec"};
1745 + static RRDSET *st_binds_external = NULL;
1746 + static RRDDIM *rd_binds_external = NULL;
1747 +
1748 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &externalBindsPerSec))
1749 + return;
1750 +
1751 + if (unlikely(!st_binds_external)) {
1752 + st_binds_external = rrdset_create_localhost(
1753 + "ad",
1754 + "binds_external",
1755 + NULL,
1756 + "bind",
1757 + "ad.binds_external",
1758 + "External binds",
1759 + "binds/s",
1760 + PLUGIN_WINDOWS_NAME,
1761 + "PerflibAD",
1762 + PRIO_AD_BIND_EXTERNAL,
1763 + update_every,
1764 + RRDSET_TYPE_LINE);
1765 +
1766 + rd_binds_external = rrddim_add(st_binds_external, "external", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1767 + }
1768 +
1769 + rrddim_set_by_pointer(st_binds_external, rd_binds_external, (collected_number)externalBindsPerSec.current.Data);
1770 + rrdset_done(st_binds_external);
1771 +}
1772 +
1773 +static void netdata_ad_binds_fast(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1774 +{
1775 + static COUNTER_DATA fastBindsPerSec = {.key = "Fast Binds/sec"};
1776 + static RRDSET *st_binds_fast = NULL;
1777 + static RRDDIM *rd_binds_fast = NULL;
1778 +
1779 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &fastBindsPerSec))
1780 + return;
1781 +
1782 + if (unlikely(!st_binds_fast)) {
1783 + st_binds_fast = rrdset_create_localhost(
1784 + "ad",
1785 + "binds_fast",
1786 + NULL,
1787 + "bind",
1788 + "ad.binds_fast",
1789 + "Fast binds",
1790 + "binds/s",
1791 + PLUGIN_WINDOWS_NAME,
1792 + "PerflibAD",
1793 + PRIO_AD_BIND_FAST,
1794 + update_every,
1795 + RRDSET_TYPE_LINE);
1796 +
1797 + rd_binds_fast = rrddim_add(st_binds_fast, "fast", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1798 + }
1799 +
1800 + rrddim_set_by_pointer(st_binds_fast, rd_binds_fast, (collected_number)fastBindsPerSec.current.Data);
1801 + rrdset_done(st_binds_fast);
1802 +}
1803 +
1804 +static void netdata_ad_binds_negotiate(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1805 +{
1806 + static COUNTER_DATA negotiatedBindsPerSec = {.key = "Negotiated Binds/sec"};
1807 + static RRDSET *st_binds_negotiate = NULL;
1808 + static RRDDIM *rd_binds_negotiate = NULL;
1809 +
1810 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &negotiatedBindsPerSec))
1811 + return;
1812 +
1813 + if (unlikely(!st_binds_negotiate)) {
1814 + st_binds_negotiate = rrdset_create_localhost(
1815 + "ad",
1816 + "binds_negotiate",
1817 + NULL,
1818 + "bind",
1819 + "ad.binds_negotiate",
1820 + "Negotiated binds",
1821 + "binds/s",
1822 + PLUGIN_WINDOWS_NAME,
1823 + "PerflibAD",
1824 + PRIO_AD_BIND_NEGOTIATE,
1825 + update_every,
1826 + RRDSET_TYPE_LINE);
1827 +
1828 + rd_binds_negotiate = rrddim_add(st_binds_negotiate, "negotiate", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1829 + }
1830 +
1831 + rrddim_set_by_pointer(st_binds_negotiate, rd_binds_negotiate, (collected_number)negotiatedBindsPerSec.current.Data);
1832 + rrdset_done(st_binds_negotiate);
1833 +}
1834 +
1835 +static void netdata_ad_binds_ntlm(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1836 +{
1837 + static COUNTER_DATA ntlmBindsPerSec = {.key = "NTLM Binds/sec"};
1838 + static RRDSET *st_binds_ntlm = NULL;
1839 + static RRDDIM *rd_binds_ntlm = NULL;
1840 +
1841 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ntlmBindsPerSec))
1842 + return;
1843 +
1844 + if (unlikely(!st_binds_ntlm)) {
1845 + st_binds_ntlm = rrdset_create_localhost(
1846 + "ad",
1847 + "binds_ntlm",
1848 + NULL,
1849 + "bind",
1850 + "ad.binds_ntlm",
1851 + "NTLM binds",
1852 + "binds/s",
1853 + PLUGIN_WINDOWS_NAME,
1854 + "PerflibAD",
1855 + PRIO_AD_BIND_NTLM,
1856 + update_every,
1857 + RRDSET_TYPE_LINE);
1858 +
1859 + rd_binds_ntlm = rrddim_add(st_binds_ntlm, "ntlm", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1860 + }
1861 +
1862 + rrddim_set_by_pointer(st_binds_ntlm, rd_binds_ntlm, (collected_number)ntlmBindsPerSec.current.Data);
1863 + rrdset_done(st_binds_ntlm);
1864 +}
1865 +
1866 +static void netdata_ad_binds_simple(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1867 +{
1868 + static COUNTER_DATA simpleBindsPerSec = {.key = "Simple Binds/sec"};
1869 + static RRDSET *st_binds_simple = NULL;
1870 + static RRDDIM *rd_binds_simple = NULL;
1871 +
1872 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &simpleBindsPerSec))
1873 + return;
1874 +
1875 + if (unlikely(!st_binds_simple)) {
1876 + st_binds_simple = rrdset_create_localhost(
1877 + "ad",
1878 + "binds_simple",
1879 + NULL,
1880 + "bind",
1881 + "ad.binds_simple",
1882 + "Simple binds",
1883 + "binds/s",
1884 + PLUGIN_WINDOWS_NAME,
1885 + "PerflibAD",
1886 + PRIO_AD_BIND_SIMPLE,
1887 + update_every,
1888 + RRDSET_TYPE_LINE);
1889 +
1890 + rd_binds_simple = rrddim_add(st_binds_simple, "simple", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1891 + }
1892 +
1893 + rrddim_set_by_pointer(st_binds_simple, rd_binds_simple, (collected_number)simpleBindsPerSec.current.Data);
1894 + rrdset_done(st_binds_simple);
1895 +}
1896 +
1897 +static void netdata_ad_binds_ldap(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1898 +{
1899 + static COUNTER_DATA ldapSuccessfulBindsPerSec = {.key = "LDAP Successful Binds/sec"};
1900 + static RRDSET *st_binds_ldap = NULL;
1901 + static RRDDIM *rd_binds_ldap = NULL;
1902 +
1903 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapSuccessfulBindsPerSec))
1904 + return;
1905 +
1906 + if (unlikely(!st_binds_ldap)) {
1907 + st_binds_ldap = rrdset_create_localhost(
1908 + "ad",
1909 + "binds_ldap",
1910 + NULL,
1911 + "bind",
1912 + "ad.binds_ldap",
1913 + "LDAP successful binds",
1914 + "binds/s",
1915 + PLUGIN_WINDOWS_NAME,
1916 + "PerflibAD",
1917 + PRIO_AD_BIND_LDAP,
1918 + update_every,
1919 + RRDSET_TYPE_LINE);
1920 +
1921 + rd_binds_ldap = rrddim_add(st_binds_ldap, "ldap", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1922 + }
1923 +
1924 + rrddim_set_by_pointer(st_binds_ldap, rd_binds_ldap, (collected_number)ldapSuccessfulBindsPerSec.current.Data);
1925 + rrdset_done(st_binds_ldap);
1926 +}
1927 +
1928 +static void netdata_ad_binds(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1929 +{
1930 + netdata_ad_binds_digest(pDataBlock, pObjectType, update_every);
1931 + netdata_ad_binds_ds_client(pDataBlock, pObjectType, update_every);
1932 + netdata_ad_binds_ds_server(pDataBlock, pObjectType, update_every);
1933 + netdata_ad_binds_external(pDataBlock, pObjectType, update_every);
1934 + netdata_ad_binds_fast(pDataBlock, pObjectType, update_every);
1935 + netdata_ad_binds_negotiate(pDataBlock, pObjectType, update_every);
1936 + netdata_ad_binds_ntlm(pDataBlock, pObjectType, update_every);
1937 + netdata_ad_binds_simple(pDataBlock, pObjectType, update_every);
1938 + netdata_ad_binds_ldap(pDataBlock, pObjectType, update_every);
1939 +}
1940 +
1941 +static void netdata_ad_bind(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1942 +{
1943 + netdata_ad_bind_time(pDataBlock, pObjectType, update_every);
1944 + netdata_ad_binds(pDataBlock, pObjectType, update_every);
1945 +}
1946 +
1947 +static void netdata_ad_atq_queue_requests(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1948 +{
1949 + static COUNTER_DATA atqOutstandingRequests = {.key = "ATQ Outstanding Queued Requests"};
1950 + static RRDSET *st_atq_outstanding_requests = NULL;
1951 + static RRDDIM *rd_atq_outstanding_requests = NULL;
1952 +
1953 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &atqOutstandingRequests)) {
1954 + if (unlikely(!st_atq_outstanding_requests)) {
1955 + st_atq_outstanding_requests = rrdset_create_localhost(
1956 + "ad",
1957 + "atq_outstanding_requests",
1958 + NULL,
1959 + "queue",
1960 + "ad.atq_outstanding_requests",
1961 + "Outstanding requests",
1962 + "requests",
1963 + PLUGIN_WINDOWS_NAME,
1964 + "PerflibAD",
1965 + PRIO_AD_OUTSTANDING_REQUEST,
1966 + update_every,
1967 + RRDSET_TYPE_LINE);
1968 +
1969 + rd_atq_outstanding_requests =
1970 + rrddim_add(st_atq_outstanding_requests, "outstanding", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1971 + }
1972 +
1973 + rrddim_set_by_pointer(
1974 + st_atq_outstanding_requests,
1975 + rd_atq_outstanding_requests,
1976 + (collected_number)atqOutstandingRequests.current.Data);
1977 + rrdset_done(st_atq_outstanding_requests);
1978 + }
1979 +}
1980 +
1981 +static void netdata_ad_atq_estimated_delay(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1982 +{
1983 + static COUNTER_DATA atqEstimatedDelay = {.key = "ATQ Estimated Queue Delay"};
1984 +
1985 + static RRDSET *st_atq_estimated_delay = NULL;
1986 + static RRDDIM *rd_atq_estimated_delay = NULL;
1987 +
1988 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &atqEstimatedDelay))
1989 + return;
1990 +
1991 + if (unlikely(!st_atq_estimated_delay)) {
1992 + st_atq_estimated_delay = rrdset_create_localhost(
1993 + "ad",
1994 + "atq_estimated_delay",
1995 + NULL,
1996 + "queue",
1997 + "ad.atq_estimated_delay",
1998 + "Estimated queue delay",
1999 + "seconds",
2000 + PLUGIN_WINDOWS_NAME,
2001 + "PerflibAD",
2002 + PRIO_AD_ATQ_ESTIMATED_DELAY,
2003 + update_every,
2004 + RRDSET_TYPE_LINE);
2005 +
2006 + rd_atq_estimated_delay = rrddim_add(st_atq_estimated_delay, "delay", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
2007 + }
2008 +
2009 + rrddim_set_by_pointer(
2010 + st_atq_estimated_delay, rd_atq_estimated_delay, (collected_number)atqEstimatedDelay.current.Data);
2011 + rrdset_done(st_atq_estimated_delay);
2012 +}
2013 +
2014 +static void
2015 +netdata_ad_atq_current_threads_ldap(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2016 +{
2017 + static COUNTER_DATA atqThreadsLDAP = {.key = "ATQ Threads LDAP"};
2018 + static RRDSET *st_atq_current_threads_ldap = NULL;
2019 + static RRDDIM *rd_atq_current_threads_ldap = NULL;
2020 +
2021 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &atqThreadsLDAP))
2022 + return;
2023 +
2024 + if (unlikely(!st_atq_current_threads_ldap)) {
2025 + st_atq_current_threads_ldap = rrdset_create_localhost(
2026 + "ad",
2027 + "atq_current_threads_ldap",
2028 + NULL,
2029 + "threads",
2030 + "ad.atq_current_threads_ldap",
2031 + "Current ATQ LDAP threads",
2032 + "threads",
2033 + PLUGIN_WINDOWS_NAME,
2034 + "PerflibAD",
2035 + PRIO_AD_ATQ_CURRENT_THREADS_LDAP,
2036 + update_every,
2037 + RRDSET_TYPE_LINE);
2038 +
2039 + rd_atq_current_threads_ldap =
2040 + rrddim_add(st_atq_current_threads_ldap, "ldap", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2041 + }
2042 +
2043 + rrddim_set_by_pointer(
2044 + st_atq_current_threads_ldap, rd_atq_current_threads_ldap, (collected_number)atqThreadsLDAP.current.Data);
2045 + rrdset_done(st_atq_current_threads_ldap);
2046 +}
2047 +
2048 +static void
2049 +netdata_ad_atq_current_threads_other(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2050 +{
2051 + static COUNTER_DATA atqThreadsOther = {.key = "ATQ Threads Other"};
2052 + static RRDSET *st_atq_current_threads_other = NULL;
2053 + static RRDDIM *rd_atq_current_threads_other = NULL;
2054 +
2055 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &atqThreadsOther))
2056 + return;
2057 +
2058 + if (unlikely(!st_atq_current_threads_other)) {
2059 + st_atq_current_threads_other = rrdset_create_localhost(
2060 + "ad",
2061 + "atq_current_threads_other",
2062 + NULL,
2063 + "threads",
2064 + "ad.atq_current_threads_other",
2065 + "Current ATQ other threads",
2066 + "threads",
2067 + PLUGIN_WINDOWS_NAME,
2068 + "PerflibAD",
2069 + PRIO_AD_ATQ_CURRENT_THREADS_OTHER,
2070 + update_every,
2071 + RRDSET_TYPE_LINE);
2072 +
2073 + rd_atq_current_threads_other =
2074 + rrddim_add(st_atq_current_threads_other, "other", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2075 + }
2076 +
2077 + rrddim_set_by_pointer(
2078 + st_atq_current_threads_other, rd_atq_current_threads_other, (collected_number)atqThreadsOther.current.Data);
2079 + rrdset_done(st_atq_current_threads_other);
2080 +}
2081 +
2082 +static void
2083 +netdata_ad_atq_current_threads_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2084 +{
2085 + static COUNTER_DATA atqThreadsTotal = {.key = "ATQ Threads Total"};
2086 + static RRDSET *st_atq_current_threads_total = NULL;
2087 + static RRDDIM *rd_atq_current_threads_total = NULL;
2088 +
2089 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &atqThreadsTotal))
2090 + return;
2091 +
2092 + if (unlikely(!st_atq_current_threads_total)) {
2093 + st_atq_current_threads_total = rrdset_create_localhost(
2094 + "ad",
2095 + "atq_current_threads_total",
2096 + NULL,
2097 + "threads",
2098 + "ad.atq_current_threads_total",
2099 + "Current ATQ total threads",
2100 + "threads",
2101 + PLUGIN_WINDOWS_NAME,
2102 + "PerflibAD",
2103 + PRIO_AD_ATQ_CURRENT_THREADS_TOTAL,
2104 + update_every,
2105 + RRDSET_TYPE_LINE);
2106 +
2107 + rd_atq_current_threads_total =
2108 + rrddim_add(st_atq_current_threads_total, "total", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2109 + }
2110 +
2111 + rrddim_set_by_pointer(
2112 + st_atq_current_threads_total, rd_atq_current_threads_total, (collected_number)atqThreadsTotal.current.Data);
2113 + rrdset_done(st_atq_current_threads_total);
2114 +}
2115 +
2116 +static void netdata_ad_atq_current_threads(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2117 +{
2118 + netdata_ad_atq_current_threads_ldap(pDataBlock, pObjectType, update_every);
2119 + netdata_ad_atq_current_threads_other(pDataBlock, pObjectType, update_every);
2120 + netdata_ad_atq_current_threads_total(pDataBlock, pObjectType, update_every);
2121 +}
2122 +
2123 +static void netdata_ad_atq_latency(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2124 +{
2125 + static COUNTER_DATA atqAverageRequestLatency = {.key = "ATQ Request Latency"};
2126 +
2127 + static RRDSET *st_atq_average_request_latency = NULL;
2128 + static RRDDIM *rd_atq_average_request_latency = NULL;
2129 +
2130 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &atqAverageRequestLatency))
2131 + return;
2132 +
2133 + if (unlikely(!st_atq_average_request_latency)) {
2134 + st_atq_average_request_latency = rrdset_create_localhost(
2135 + "ad",
2136 + "atq_average_request_latency",
2137 + NULL,
2138 + "queue",
2139 + "ad.atq_average_request_latency",
2140 + "Average request processing time",
2141 + "seconds",
2142 + PLUGIN_WINDOWS_NAME,
2143 + "PerflibAD",
2144 + PRIO_AD_AVG_REQUEST_LATENCY,
2145 + update_every,
2146 + RRDSET_TYPE_LINE);
2147 +
2148 + rd_atq_average_request_latency =
2149 + rrddim_add(st_atq_average_request_latency, "time", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
2150 + }
2151 +
2152 + rrddim_set_by_pointer(
2153 + st_atq_average_request_latency,
2154 + rd_atq_average_request_latency,
2155 + (collected_number)atqAverageRequestLatency.current.Data);
2156 + rrdset_done(st_atq_average_request_latency);
2157 +}
2158 +
2159 +static void netdata_ad_op_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2160 +{
2161 + static COUNTER_DATA databaseAddsPerSec = {.key = "Database adds/sec"};
2162 + static COUNTER_DATA databaseDeletesPerSec = {.key = "Database deletes/sec"};
2163 + static COUNTER_DATA databaseModifiesPerSec = {.key = "Database modifys/sec"};
2164 + static COUNTER_DATA databaseRecyclesPerSec = {.key = "Database recycles/sec"};
2165 +
2166 + static RRDSET *st_database_operation_total = NULL;
2167 + static RRDDIM *rd_database_operation_total_add = NULL;
2168 + static RRDDIM *rd_database_operation_total_delete = NULL;
2169 + static RRDDIM *rd_database_operation_total_modify = NULL;
2170 + static RRDDIM *rd_database_operation_total_recycle = NULL;
2171 +
2172 + perflibGetObjectCounter(pDataBlock, pObjectType, &databaseAddsPerSec);
2173 + perflibGetObjectCounter(pDataBlock, pObjectType, &databaseDeletesPerSec);
2174 + perflibGetObjectCounter(pDataBlock, pObjectType, &databaseModifiesPerSec);
2175 + perflibGetObjectCounter(pDataBlock, pObjectType, &databaseRecyclesPerSec);
2176 +
2177 + if (unlikely(!st_database_operation_total)) {
2178 + st_database_operation_total = rrdset_create_localhost(
2179 + "ad",
2180 + "database_operations",
2181 + NULL,
2182 + "database",
2183 + "ad.database_operations",
2184 + "AD database operations",
2185 + "operations/s",
2186 + PLUGIN_WINDOWS_NAME,
2187 + "PerflibAD",
2188 + PRIO_AD_OPERATIONS_TOTAL,
2189 + update_every,
2190 + RRDSET_TYPE_LINE);
2191 +
2192 + rd_database_operation_total_add =
2193 + rrddim_add(st_database_operation_total, "add", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2194 +
2195 + rd_database_operation_total_delete =
2196 + rrddim_add(st_database_operation_total, "delete", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2197 +
2198 + rd_database_operation_total_modify =
2199 + rrddim_add(st_database_operation_total, "modify", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2200 +
2201 + rd_database_operation_total_recycle =
2202 + rrddim_add(st_database_operation_total, "recycle", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2203 + }
2204 +
2205 + rrddim_set_by_pointer(
2206 + st_database_operation_total,
2207 + rd_database_operation_total_add,
2208 + (collected_number)databaseAddsPerSec.current.Data);
2209 +
2210 + rrddim_set_by_pointer(
2211 + st_database_operation_total,
2212 + rd_database_operation_total_delete,
2213 + (collected_number)databaseDeletesPerSec.current.Data);
2214 +
2215 + rrddim_set_by_pointer(
2216 + st_database_operation_total,
2217 + rd_database_operation_total_modify,
2218 + (collected_number)databaseModifiesPerSec.current.Data);
2219 +
2220 + rrddim_set_by_pointer(
2221 + st_database_operation_total,
2222 + rd_database_operation_total_recycle,
2223 + (collected_number)databaseRecyclesPerSec.current.Data);
2224 +
2225 + rrdset_done(st_database_operation_total);
2226 +}
2227 +
2228 +static void netdata_ad_directory_reads(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2229 +{
2230 + static COUNTER_DATA directoryReadsPerSec = {.key = "DS Directory Reads/sec"};
2231 + static RRDSET *st_directory_reads = NULL;
2232 + static RRDDIM *rd_directory_reads = NULL;
2233 +
2234 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &directoryReadsPerSec))
2235 + return;
2236 +
2237 + if (unlikely(!st_directory_reads)) {
2238 + st_directory_reads = rrdset_create_localhost(
2239 + "ad",
2240 + "directory_reads",
2241 + NULL,
2242 + "directory",
2243 + "ad.directory_reads",
2244 + "Directory reads",
2245 + "reads/s",
2246 + PLUGIN_WINDOWS_NAME,
2247 + "PerflibAD",
2248 + PRIO_AD_DIRECTORY_READS,
2249 + update_every,
2250 + RRDSET_TYPE_LINE);
2251 +
2252 + rd_directory_reads = rrddim_add(st_directory_reads, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2253 + }
2254 +
2255 + rrddim_set_by_pointer(st_directory_reads, rd_directory_reads, (collected_number)directoryReadsPerSec.current.Data);
2256 + rrdset_done(st_directory_reads);
2257 +}
2258 +
2259 +static void netdata_ad_directory_searches(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2260 +{
2261 + static COUNTER_DATA directorySearchesPerSec = {.key = "DS Directory Searches/sec"};
2262 + static RRDSET *st_directory_searches = NULL;
2263 + static RRDDIM *rd_directory_searches = NULL;
2264 +
2265 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &directorySearchesPerSec))
2266 + return;
2267 +
2268 + if (unlikely(!st_directory_searches)) {
2269 + st_directory_searches = rrdset_create_localhost(
2270 + "ad",
2271 + "directory_searches",
2272 + NULL,
2273 + "directory",
2274 + "ad.directory_searches",
2275 + "Directory searches",
2276 + "searches/s",
2277 + PLUGIN_WINDOWS_NAME,
2278 + "PerflibAD",
2279 + PRIO_AD_DIRECTORY_SEARCHES,
2280 + update_every,
2281 + RRDSET_TYPE_LINE);
2282 +
2283 + rd_directory_searches = rrddim_add(st_directory_searches, "search", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2284 + }
2285 +
2286 + rrddim_set_by_pointer(
2287 + st_directory_searches, rd_directory_searches, (collected_number)directorySearchesPerSec.current.Data);
2288 + rrdset_done(st_directory_searches);
2289 +}
2290 +
2291 +static void netdata_ad_directory_writes(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2292 +{
2293 + static COUNTER_DATA directoryWritesPerSec = {.key = "DS Directory Writes/sec"};
2294 + static RRDSET *st_directory_writes = NULL;
2295 + static RRDDIM *rd_directory_writes = NULL;
2296 +
2297 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &directoryWritesPerSec))
2298 + return;
2299 +
2300 + if (unlikely(!st_directory_writes)) {
2301 + st_directory_writes = rrdset_create_localhost(
2302 + "ad",
2303 + "directory_writes",
2304 + NULL,
2305 + "directory",
2306 + "ad.directory_writes",
2307 + "Directory writes",
2308 + "writes/s",
2309 + PLUGIN_WINDOWS_NAME,
2310 + "PerflibAD",
2311 + PRIO_AD_DIRECTORY_WRITES,
2312 + update_every,
2313 + RRDSET_TYPE_LINE);
2314 +
2315 + rd_directory_writes = rrddim_add(st_directory_writes, "write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2316 + }
2317 +
2318 + rrddim_set_by_pointer(
2319 + st_directory_writes, rd_directory_writes, (collected_number)directoryWritesPerSec.current.Data);
2320 + rrdset_done(st_directory_writes);
2321 +}
2322 +
2323 +static void netdata_ad_replication_inbound_object_updates_remaining(
2324 + PERF_DATA_BLOCK *pDataBlock,
2325 + PERF_OBJECT_TYPE *pObjectType,
2326 + int update_every)
2327 +{
2328 + static COUNTER_DATA replicationInboundObjectUpdatesRemainingInPacket = {
2329 + .key = "DRA Inbound Object Updates Remaining in Packet"};
2330 + static RRDSET *st_replication_inbound_object_updates_remaining = NULL;
2331 + static RRDDIM *rd_replication_inbound_object_updates_remaining = NULL;
2332 +
2333 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundObjectUpdatesRemainingInPacket))
2334 + return;
2335 +
2336 + if (unlikely(!st_replication_inbound_object_updates_remaining)) {
2337 + st_replication_inbound_object_updates_remaining = rrdset_create_localhost(
2338 + "ad",
2339 + "replication_inbound_object_updates_remaining",
2340 + NULL,
2341 + "replication",
2342 + "ad.replication_inbound_object_updates_remaining",
2343 + "Replication inbound object updates remaining",
2344 + "updates",
2345 + PLUGIN_WINDOWS_NAME,
2346 + "PerflibAD",
2347 + PRIO_AD_REPLICATION_INBOUND_OBJECT_UPDATES_REMAINING,
2348 + update_every,
2349 + RRDSET_TYPE_LINE);
2350 +
2351 + rd_replication_inbound_object_updates_remaining = rrddim_add(
2352 + st_replication_inbound_object_updates_remaining, "remaining", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2353 + }
2354 +
2355 + rrddim_set_by_pointer(
2356 + st_replication_inbound_object_updates_remaining,
2357 + rd_replication_inbound_object_updates_remaining,
2358 + (collected_number)replicationInboundObjectUpdatesRemainingInPacket.current.Data);
2359 + rrdset_done(st_replication_inbound_object_updates_remaining);
2360 +}
2361 +
2362 +static void netdata_ad_replication_inbound_values_dns_only(
2363 + PERF_DATA_BLOCK *pDataBlock,
2364 + PERF_OBJECT_TYPE *pObjectType,
2365 + int update_every)
2366 +{
2367 + static COUNTER_DATA replicationInboundValuesDNsOnlyPerSec = {.key = "DRA Inbound Values (DNs only)/sec"};
2368 + static RRDSET *st_replication_inbound_values_dns_only = NULL;
2369 + static RRDDIM *rd_replication_inbound_values_dns_only = NULL;
2370 +
2371 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundValuesDNsOnlyPerSec))
2372 + return;
2373 +
2374 + if (unlikely(!st_replication_inbound_values_dns_only)) {
2375 + st_replication_inbound_values_dns_only = rrdset_create_localhost(
2376 + "ad",
2377 + "replication_inbound_values_dns_only",
2378 + NULL,
2379 + "replication",
2380 + "ad.replication_inbound_values_dns_only",
2381 + "DRA replication inbound values DNs only",
2382 + "values/s",
2383 + PLUGIN_WINDOWS_NAME,
2384 + "PerflibAD",
2385 + PRIO_AD_REPLICATION_INBOUND_VALUES_DNS_ONLY,
2386 + update_every,
2387 + RRDSET_TYPE_LINE);
2388 +
2389 + rd_replication_inbound_values_dns_only =
2390 + rrddim_add(st_replication_inbound_values_dns_only, "dns_only", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2391 + }
2392 +
2393 + rrddim_set_by_pointer(
2394 + st_replication_inbound_values_dns_only,
2395 + rd_replication_inbound_values_dns_only,
2396 + (collected_number)replicationInboundValuesDNsOnlyPerSec.current.Data);
2397 + rrdset_done(st_replication_inbound_values_dns_only);
2398 +}
2399 +
2400 +static void
2401 +netdata_ad_replication_inbound_values_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2402 +{
2403 + static COUNTER_DATA replicationInboundValuesTotalPerSec = {.key = "DRA Inbound Values Total/sec"};
2404 + static RRDSET *st_replication_inbound_values_total = NULL;
2405 + static RRDDIM *rd_replication_inbound_values_total = NULL;
2406 +
2407 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundValuesTotalPerSec))
2408 + return;
2409 +
2410 + if (unlikely(!st_replication_inbound_values_total)) {
2411 + st_replication_inbound_values_total = rrdset_create_localhost(
2412 + "ad",
2413 + "replication_inbound_values_total",
2414 + NULL,
2415 + "replication",
2416 + "ad.replication_inbound_values_total",
2417 + "DRA replication inbound values total",
2418 + "values/s",
2419 + PLUGIN_WINDOWS_NAME,
2420 + "PerflibAD",
2421 + PRIO_AD_REPLICATION_INBOUND_VALUES_TOTAL,
2422 + update_every,
2423 + RRDSET_TYPE_LINE);
2424 +
2425 + rd_replication_inbound_values_total =
2426 + rrddim_add(st_replication_inbound_values_total, "total", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2427 + }
2428 +
2429 + rrddim_set_by_pointer(
2430 + st_replication_inbound_values_total,
2431 + rd_replication_inbound_values_total,
2432 + (collected_number)replicationInboundValuesTotalPerSec.current.Data);
2433 + rrdset_done(st_replication_inbound_values_total);
2434 +}
2435 +
2436 +static void netdata_ad_replication_outbound_objects_filtered(
2437 + PERF_DATA_BLOCK *pDataBlock,
2438 + PERF_OBJECT_TYPE *pObjectType,
2439 + int update_every)
2440 +{
2441 + static COUNTER_DATA replicationOutboundObjectsFilteredPerSec = {.key = "DRA Outbound Objects Filtered/sec"};
2442 + static RRDSET *st_replication_outbound_objects_filtered = NULL;
2443 + static RRDDIM *rd_replication_outbound_objects_filtered = NULL;
2444 +
2445 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationOutboundObjectsFilteredPerSec))
2446 + return;
2447 +
2448 + if (unlikely(!st_replication_outbound_objects_filtered)) {
2449 + st_replication_outbound_objects_filtered = rrdset_create_localhost(
2450 + "ad",
2451 + "replication_outbound_objects_filtered",
2452 + NULL,
2453 + "replication",
2454 + "ad.replication_outbound_objects_filtered",
2455 + "Replication outbound objects filtered",
2456 + "objects/s",
2457 + PLUGIN_WINDOWS_NAME,
2458 + "PerflibAD",
2459 + PRIO_AD_REPLICATION_OUTBOUND_OBJECTS_FILTERED,
2460 + update_every,
2461 + RRDSET_TYPE_LINE);
2462 +
2463 + rd_replication_outbound_objects_filtered =
2464 + rrddim_add(st_replication_outbound_objects_filtered, "filtered", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2465 + }
2466 +
2467 + rrddim_set_by_pointer(
2468 + st_replication_outbound_objects_filtered,
2469 + rd_replication_outbound_objects_filtered,
2470 + (collected_number)replicationOutboundObjectsFilteredPerSec.current.Data);
2471 + rrdset_done(st_replication_outbound_objects_filtered);
2472 +}
2473 +
2474 +static void
2475 +netdata_ad_replication_outbound_objects(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2476 +{
2477 + static COUNTER_DATA replicationOutboundObjectsPerSec = {.key = "DRA Outbound Objects/sec"};
2478 + static RRDSET *st_replication_outbound_objects = NULL;
2479 + static RRDDIM *rd_replication_outbound_objects = NULL;
2480 +
2481 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationOutboundObjectsPerSec))
2482 + return;
2483 +
2484 + if (unlikely(!st_replication_outbound_objects)) {
2485 + st_replication_outbound_objects = rrdset_create_localhost(
2486 + "ad",
2487 + "replication_outbound_objects",
2488 + NULL,
2489 + "replication",
2490 + "ad.replication_outbound_objects",
2491 + "Replication outbound objects",
2492 + "objects/s",
2493 + PLUGIN_WINDOWS_NAME,
2494 + "PerflibAD",
2495 + PRIO_AD_REPLICATION_OUTBOUND_OBJECTS,
2496 + update_every,
2497 + RRDSET_TYPE_LINE);
2498 +
2499 + rd_replication_outbound_objects =
2500 + rrddim_add(st_replication_outbound_objects, "objects", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2501 + }
2502 +
2503 + rrddim_set_by_pointer(
2504 + st_replication_outbound_objects,
2505 + rd_replication_outbound_objects,
2506 + (collected_number)replicationOutboundObjectsPerSec.current.Data);
2507 + rrdset_done(st_replication_outbound_objects);
2508 +}
2509 +
2510 +static void
2511 +netdata_ad_replication_outbound_properties(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2512 +{
2513 + static COUNTER_DATA replicationOutboundPropertiesPerSec = {.key = "DRA Outbound Properties/sec"};
2514 + static RRDSET *st_replication_outbound_properties = NULL;
2515 + static RRDDIM *rd_replication_outbound_properties = NULL;
2516 +
2517 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationOutboundPropertiesPerSec))
2518 + return;
2519 +
2520 + if (unlikely(!st_replication_outbound_properties)) {
2521 + st_replication_outbound_properties = rrdset_create_localhost(
2522 + "ad",
2523 + "replication_outbound_properties",
2524 + NULL,
2525 + "replication",
2526 + "ad.replication_outbound_properties",
2527 + "Replication outbound properties",
2528 + "properties/s",
2529 + PLUGIN_WINDOWS_NAME,
2530 + "PerflibAD",
2531 + PRIO_AD_REPLICATION_OUTBOUND_PROPERTIES,
2532 + update_every,
2533 + RRDSET_TYPE_LINE);
2534 +
2535 + rd_replication_outbound_properties =
2536 + rrddim_add(st_replication_outbound_properties, "properties", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2537 + }
2538 +
2539 + rrddim_set_by_pointer(
2540 + st_replication_outbound_properties,
2541 + rd_replication_outbound_properties,
2542 + (collected_number)replicationOutboundPropertiesPerSec.current.Data);
2543 + rrdset_done(st_replication_outbound_properties);
2544 +}
2545 +
2546 +static void netdata_ad_replication_outbound_values_dns_only(
2547 + PERF_DATA_BLOCK *pDataBlock,
2548 + PERF_OBJECT_TYPE *pObjectType,
2549 + int update_every)
2550 +{
2551 + static COUNTER_DATA replicationOutboundValuesDNsOnlyPerSec = {.key = "DRA Outbound Values (DNs only)/sec"};
2552 + static RRDSET *st_replication_outbound_values_dns_only = NULL;
2553 + static RRDDIM *rd_replication_outbound_values_dns_only = NULL;
2554 +
2555 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationOutboundValuesDNsOnlyPerSec))
2556 + return;
2557 +
2558 + if (unlikely(!st_replication_outbound_values_dns_only)) {
2559 + st_replication_outbound_values_dns_only = rrdset_create_localhost(
2560 + "ad",
2561 + "replication_outbound_values_dns_only",
2562 + NULL,
2563 + "replication",
2564 + "ad.replication_outbound_values_dns_only",
2565 + "DRA replication outbound values DNs only",
2566 + "values/s",
2567 + PLUGIN_WINDOWS_NAME,
2568 + "PerflibAD",
2569 + PRIO_AD_REPLICATION_OUTBOUND_VALUES_DNS_ONLY,
2570 + update_every,
2571 + RRDSET_TYPE_LINE);
2572 +
2573 + rd_replication_outbound_values_dns_only =
2574 + rrddim_add(st_replication_outbound_values_dns_only, "dns_only", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2575 + }
2576 +
2577 + rrddim_set_by_pointer(
2578 + st_replication_outbound_values_dns_only,
2579 + rd_replication_outbound_values_dns_only,
2580 + (collected_number)replicationOutboundValuesDNsOnlyPerSec.current.Data);
2581 + rrdset_done(st_replication_outbound_values_dns_only);
2582 +}
2583 +
2584 +static void netdata_ad_replication_outbound_values_total(
2585 + PERF_DATA_BLOCK *pDataBlock,
2586 + PERF_OBJECT_TYPE *pObjectType,
2587 + int update_every)
2588 +{
2589 + static COUNTER_DATA replicationOutboundValuesTotalPerSec = {.key = "DRA Outbound Values Total/sec"};
2590 + static RRDSET *st_replication_outbound_values_total = NULL;
2591 + static RRDDIM *rd_replication_outbound_values_total = NULL;
2592 +
2593 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationOutboundValuesTotalPerSec))
2594 + return;
2595 +
2596 + if (unlikely(!st_replication_outbound_values_total)) {
2597 + st_replication_outbound_values_total = rrdset_create_localhost(
2598 + "ad",
2599 + "replication_outbound_values_total",
2600 + NULL,
2601 + "replication",
2602 + "ad.replication_outbound_values_total",
2603 + "DRA replication outbound values total",
2604 + "values/s",
2605 + PLUGIN_WINDOWS_NAME,
2606 + "PerflibAD",
2607 + PRIO_AD_REPLICATION_OUTBOUND_VALUES_TOTAL,
2608 + update_every,
2609 + RRDSET_TYPE_LINE);
2610 +
2611 + rd_replication_outbound_values_total =
2612 + rrddim_add(st_replication_outbound_values_total, "total", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2613 + }
2614 +
2615 + rrddim_set_by_pointer(
2616 + st_replication_outbound_values_total,
2617 + rd_replication_outbound_values_total,
2618 + (collected_number)replicationOutboundValuesTotalPerSec.current.Data);
2619 + rrdset_done(st_replication_outbound_values_total);
2620 +}
2621 +
2622 +static void netdata_ad_replication_threads_getting_nc_changes(
2623 + PERF_DATA_BLOCK *pDataBlock,
2624 + PERF_OBJECT_TYPE *pObjectType,
2625 + int update_every)
2626 +{
2627 + static COUNTER_DATA draThreadsGettingNCChanges = {.key = "DRA Threads Getting NC Changes"};
2628 + static RRDSET *st_replication_threads_getting_nc_changes = NULL;
2629 + static RRDDIM *rd_replication_threads_getting_nc_changes = NULL;
2630 +
2631 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &draThreadsGettingNCChanges))
2632 + return;
2633 +
2634 + if (unlikely(!st_replication_threads_getting_nc_changes)) {
2635 + st_replication_threads_getting_nc_changes = rrdset_create_localhost(
2636 + "ad",
2637 + "replication_threads_getting_nc_changes",
2638 + NULL,
2639 + "replication",
2640 + "ad.replication_threads_getting_nc_changes",
2641 + "DRA threads getting NC changes",
2642 + "threads",
2643 + PLUGIN_WINDOWS_NAME,
2644 + "PerflibAD",
2645 + PRIO_AD_REPLICATION_THREADS_GETTING_NC_CHANGES,
2646 + update_every,
2647 + RRDSET_TYPE_LINE);
2648 +
2649 + rd_replication_threads_getting_nc_changes =
2650 + rrddim_add(st_replication_threads_getting_nc_changes, "threads", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2651 + }
2652 +
2653 + rrddim_set_by_pointer(
2654 + st_replication_threads_getting_nc_changes,
2655 + rd_replication_threads_getting_nc_changes,
2656 + (collected_number)draThreadsGettingNCChanges.current.Data);
2657 + rrdset_done(st_replication_threads_getting_nc_changes);
2658 +}
2659 +
2660 +static void netdata_ad_replication_threads_getting_nc_changes_holding_semaphore(
2661 + PERF_DATA_BLOCK *pDataBlock,
2662 + PERF_OBJECT_TYPE *pObjectType,
2663 + int update_every)
2664 +{
2665 + static COUNTER_DATA draThreadsGettingNCChangesHoldingSemaphore = {
2666 + .key = "DRA Threads Getting NC Changes Holding Semaphore"};
2667 + static RRDSET *st_replication_threads_getting_nc_changes_holding_semaphore = NULL;
2668 + static RRDDIM *rd_replication_threads_getting_nc_changes_holding_semaphore = NULL;
2669 +
2670 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &draThreadsGettingNCChangesHoldingSemaphore))
2671 + return;
2672 +
2673 + if (unlikely(!st_replication_threads_getting_nc_changes_holding_semaphore)) {
2674 + st_replication_threads_getting_nc_changes_holding_semaphore = rrdset_create_localhost(
2675 + "ad",
2676 + "replication_threads_getting_nc_changes_holding_semaphore",
2677 + NULL,
2678 + "replication",
2679 + "ad.replication_threads_getting_nc_changes_holding_semaphore",
2680 + "DRA threads getting NC changes holding semaphore",
2681 + "threads",
2682 + PLUGIN_WINDOWS_NAME,
2683 + "PerflibAD",
2684 + PRIO_AD_REPLICATION_THREADS_GETTING_NC_CHANGES_HOLDING_SEMAPHORE,
2685 + update_every,
2686 + RRDSET_TYPE_LINE);
2687 +
2688 + rd_replication_threads_getting_nc_changes_holding_semaphore = rrddim_add(
2689 + st_replication_threads_getting_nc_changes_holding_semaphore, "threads", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2690 + }
2691 +
2692 + rrddim_set_by_pointer(
2693 + st_replication_threads_getting_nc_changes_holding_semaphore,
2694 + rd_replication_threads_getting_nc_changes_holding_semaphore,
2695 + (collected_number)draThreadsGettingNCChangesHoldingSemaphore.current.Data);
2696 + rrdset_done(st_replication_threads_getting_nc_changes_holding_semaphore);
2697 +}
2698 +
2699 +static void
2700 +netdata_ad_transitive_operations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2701 +{
2702 + static COUNTER_DATA transitiveOperationsPerSec = {.key = "Transitive operations/sec"};
2703 + static RRDSET *st_transitive_operations = NULL;
2704 + static RRDDIM *rd_transitive_operations = NULL;
2705 +
2706 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &transitiveOperationsPerSec))
2707 + return;
2708 +
2709 + if (unlikely(!st_transitive_operations)) {
2710 + st_transitive_operations = rrdset_create_localhost(
2711 + "ad",
2712 + "transitive_operations",
2713 + NULL,
2714 + "database",
2715 + "ad.transitive_operations",
2716 + "Transitive operations",
2717 + "operations/s",
2718 + PLUGIN_WINDOWS_NAME,
2719 + "PerflibAD",
2720 + PRIO_AD_TRANSITIVE_OPERATIONS,
2721 + update_every,
2722 + RRDSET_TYPE_LINE);
2723 +
2724 + rd_transitive_operations =
2725 + rrddim_add(st_transitive_operations, "operations", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2726 + }
2727 +
2728 + rrddim_set_by_pointer(
2729 + st_transitive_operations, rd_transitive_operations, (collected_number)transitiveOperationsPerSec.current.Data);
2730 + rrdset_done(st_transitive_operations);
2731 +}
2732 +
2733 +static void
2734 +netdata_ad_transitive_suboperations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2735 +{
2736 + static COUNTER_DATA transitiveSubOperationsPerSec = {.key = "Transitive suboperations/sec"};
2737 + static RRDSET *st_transitive_suboperations = NULL;
2738 + static RRDDIM *rd_transitive_suboperations = NULL;
2739 +
2740 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &transitiveSubOperationsPerSec))
2741 + return;
2742 +
2743 + if (unlikely(!st_transitive_suboperations)) {
2744 + st_transitive_suboperations = rrdset_create_localhost(
2745 + "ad",
2746 + "transitive_suboperations",
2747 + NULL,
2748 + "database",
2749 + "ad.transitive_suboperations",
2750 + "Transitive suboperations",
2751 + "suboperations/s",
2752 + PLUGIN_WINDOWS_NAME,
2753 + "PerflibAD",
2754 + PRIO_AD_TRANSITIVE_SUBOPERATIONS,
2755 + update_every,
2756 + RRDSET_TYPE_LINE);
2757 +
2758 + rd_transitive_suboperations =
2759 + rrddim_add(st_transitive_suboperations, "suboperations", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2760 + }
2761 +
2762 + rrddim_set_by_pointer(
2763 + st_transitive_suboperations,
2764 + rd_transitive_suboperations,
2765 + (collected_number)transitiveSubOperationsPerSec.current.Data);
2766 + rrdset_done(st_transitive_suboperations);
2767 +}
2768 +
2769 +static void
2770 +netdata_ad_replication_inbound_bytes_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2771 +{
2772 + static COUNTER_DATA replicationInboundBytesTotalPerSec = {.key = "DRA Inbound Bytes Total/sec"};
2773 + static RRDSET *st_replication_inbound_bytes_total = NULL;
2774 + static RRDDIM *rd_replication_inbound_bytes_total = NULL;
2775 +
2776 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationInboundBytesTotalPerSec))
2777 + return;
2778 +
2779 + if (unlikely(!st_replication_inbound_bytes_total)) {
2780 + st_replication_inbound_bytes_total = rrdset_create_localhost(
2781 + "ad",
2782 + "replication_inbound_bytes_total",
2783 + NULL,
2784 + "replication",
2785 + "ad.replication_inbound_bytes_total",
2786 + "DRA replication inbound bytes total",
2787 + "bytes/s",
2788 + PLUGIN_WINDOWS_NAME,
2789 + "PerflibAD",
2790 + PRIO_AD_REPLICATION_INBOUND_BYTES_TOTAL,
2791 + update_every,
2792 + RRDSET_TYPE_LINE);
2793 +
2794 + rd_replication_inbound_bytes_total =
2795 + rrddim_add(st_replication_inbound_bytes_total, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2796 + }
2797 +
2798 + rrddim_set_by_pointer(
2799 + st_replication_inbound_bytes_total,
2800 + rd_replication_inbound_bytes_total,
2801 + (collected_number)replicationInboundBytesTotalPerSec.current.Data);
2802 + rrdset_done(st_replication_inbound_bytes_total);
2803 +}
2804 +
2805 +static void
2806 +netdata_ad_replication_outbound_bytes_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2807 +{
2808 + static COUNTER_DATA replicationOutboundBytesTotalPerSec = {.key = "DRA Outbound Bytes Total/sec"};
2809 + static RRDSET *st_replication_outbound_bytes_total = NULL;
2810 + static RRDDIM *rd_replication_outbound_bytes_total = NULL;
2811 +
2812 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &replicationOutboundBytesTotalPerSec))
2813 + return;
2814 +
2815 + if (unlikely(!st_replication_outbound_bytes_total)) {
2816 + st_replication_outbound_bytes_total = rrdset_create_localhost(
2817 + "ad",
2818 + "replication_outbound_bytes_total",
2819 + NULL,
2820 + "replication",
2821 + "ad.replication_outbound_bytes_total",
2822 + "DRA replication outbound bytes total",
2823 + "bytes/s",
2824 + PLUGIN_WINDOWS_NAME,
2825 + "PerflibAD",
2826 + PRIO_AD_REPLICATION_OUTBOUND_BYTES_TOTAL,
2827 + update_every,
2828 + RRDSET_TYPE_LINE);
2829 +
2830 + rd_replication_outbound_bytes_total =
2831 + rrddim_add(st_replication_outbound_bytes_total, "outbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2832 + }
2833 +
2834 + rrddim_set_by_pointer(
2835 + st_replication_outbound_bytes_total,
2836 + rd_replication_outbound_bytes_total,
2837 + (collected_number)replicationOutboundBytesTotalPerSec.current.Data);
2838 + rrdset_done(st_replication_outbound_bytes_total);
2839 +}
2840 +
2841 +static void
2842 +netdata_ad_ldap_closed_connections(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2843 +{
2844 + static COUNTER_DATA ldapClosedConnectionsPerSec = {.key = "LDAP Closed Connections/sec"};
2845 + static RRDSET *st_ldap_closed_connections_total = NULL;
2846 + static RRDDIM *rd_ldap_closed_connections_total = NULL;
2847 +
2848 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapClosedConnectionsPerSec))
2849 + return;
2850 +
2851 + if (unlikely(!st_ldap_closed_connections_total)) {
2852 + st_ldap_closed_connections_total = rrdset_create_localhost(
2853 + "ad",
2854 + "ldap_closed_connections",
2855 + NULL,
2856 + "ldap",
2857 + "ad.ldap_closed_connections",
2858 + "LDAP closed connections",
2859 + "connections/s",
2860 + PLUGIN_WINDOWS_NAME,
2861 + "PerflibAD",
2862 + PRIO_AD_LDAP_CLOSED_CONNECTIONS_TOTAL,
2863 + update_every,
2864 + RRDSET_TYPE_LINE);
2865 +
2866 + rd_ldap_closed_connections_total =
2867 + rrddim_add(st_ldap_closed_connections_total, "closed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2868 + }
2869 +
2870 + rrddim_set_by_pointer(
2871 + st_ldap_closed_connections_total,
2872 + rd_ldap_closed_connections_total,
2873 + (collected_number)ldapClosedConnectionsPerSec.current.Data);
2874 + rrdset_done(st_ldap_closed_connections_total);
2875 +}
2876 +
2877 +static void
2878 +netdata_ad_ldap_opened_connections_ldap(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2879 +{
2880 + static COUNTER_DATA ldapNewConnectionsPerSec = {.key = "LDAP New Connections/sec"};
2881 + static RRDSET *st_ldap_opened_connections_ldap = NULL;
2882 + static RRDDIM *rd_ldap_opened_connections_ldap = NULL;
2883 +
2884 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapNewConnectionsPerSec))
2885 + return;
2886 +
2887 + if (unlikely(!st_ldap_opened_connections_ldap)) {
2888 + st_ldap_opened_connections_ldap = rrdset_create_localhost(
2889 + "ad",
2890 + "ldap_opened_connections_ldap",
2891 + NULL,
2892 + "ldap",
2893 + "ad.ldap_opened_connections_ldap",
2894 + "LDAP opened connections",
2895 + "connections/s",
2896 + PLUGIN_WINDOWS_NAME,
2897 + "PerflibAD",
2898 + PRIO_AD_LDAP_OPENED_CONNECTIONS_LDAP,
2899 + update_every,
2900 + RRDSET_TYPE_LINE);
2901 +
2902 + rd_ldap_opened_connections_ldap =
2903 + rrddim_add(st_ldap_opened_connections_ldap, "ldap", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2904 + }
2905 +
2906 + rrddim_set_by_pointer(
2907 + st_ldap_opened_connections_ldap,
2908 + rd_ldap_opened_connections_ldap,
2909 + (collected_number)ldapNewConnectionsPerSec.current.Data);
2910 + rrdset_done(st_ldap_opened_connections_ldap);
2911 +}
2912 +
2913 +static void
2914 +netdata_ad_ldap_opened_connections_ldaps(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2915 +{
2916 + static COUNTER_DATA ldapNewSSLConnectionsPerSec = {.key = "LDAP New SSL Connections/sec"};
2917 + static RRDSET *st_ldap_opened_connections_ldaps = NULL;
2918 + static RRDDIM *rd_ldap_opened_connections_ldaps = NULL;
2919 +
2920 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapNewSSLConnectionsPerSec))
2921 + return;
2922 +
2923 + if (unlikely(!st_ldap_opened_connections_ldaps)) {
2924 + st_ldap_opened_connections_ldaps = rrdset_create_localhost(
2925 + "ad",
2926 + "ldap_opened_connections_ldaps",
2927 + NULL,
2928 + "ldap",
2929 + "ad.ldap_opened_connections_ldaps",
2930 + "LDAPS opened connections",
2931 + "connections/s",
2932 + PLUGIN_WINDOWS_NAME,
2933 + "PerflibAD",
2934 + PRIO_AD_LDAP_OPENED_CONNECTIONS_LDAPS,
2935 + update_every,
2936 + RRDSET_TYPE_LINE);
2937 +
2938 + rd_ldap_opened_connections_ldaps =
2939 + rrddim_add(st_ldap_opened_connections_ldaps, "ldaps", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2940 + }
2941 +
2942 + rrddim_set_by_pointer(
2943 + st_ldap_opened_connections_ldaps,
2944 + rd_ldap_opened_connections_ldaps,
2945 + (collected_number)ldapNewSSLConnectionsPerSec.current.Data);
2946 + rrdset_done(st_ldap_opened_connections_ldaps);
2947 +}
2948 +
2949 +static void netdata_ad_ldap_active_threads(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2950 +{
2951 + static COUNTER_DATA ldapActiveThreads = {.key = "LDAP Active Threads"};
2952 + static RRDSET *st_ldap_active_threads = NULL;
2953 + static RRDDIM *rd_ldap_active_threads = NULL;
2954 +
2955 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapActiveThreads))
2956 + return;
2957 +
2958 + if (unlikely(!st_ldap_active_threads)) {
2959 + st_ldap_active_threads = rrdset_create_localhost(
2960 + "ad",
2961 + "ldap_active_threads",
2962 + NULL,
2963 + "threads",
2964 + "ad.ldap_active_threads",
2965 + "LDAP active threads",
2966 + "threads",
2967 + PLUGIN_WINDOWS_NAME,
2968 + "PerflibAD",
2969 + PRIO_AD_LDAP_ACTIVE_THREADS,
2970 + update_every,
2971 + RRDSET_TYPE_LINE);
2972 +
2973 + rd_ldap_active_threads = rrddim_add(st_ldap_active_threads, "active", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2974 + }
2975 +
2976 + rrddim_set_by_pointer(
2977 + st_ldap_active_threads, rd_ldap_active_threads, (collected_number)ldapActiveThreads.current.Data);
2978 + rrdset_done(st_ldap_active_threads);
2979 +}
2980 +
2981 +static void netdata_ad_ldap_udp_operations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
2982 +{
2983 + static COUNTER_DATA ldapUDPOperationsPerSec = {.key = "LDAP UDP operations/sec"};
2984 + static RRDSET *st_ldap_udp_operations_total = NULL;
2985 + static RRDDIM *rd_ldap_udp_operations_total = NULL;
2986 +
2987 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapUDPOperationsPerSec))
2988 + return;
2989 +
2990 + if (unlikely(!st_ldap_udp_operations_total)) {
2991 + st_ldap_udp_operations_total = rrdset_create_localhost(
2992 + "ad",
2993 + "ldap_udp_operations",
2994 + NULL,
2995 + "ldap",
2996 + "ad.ldap_udp_operations",
2997 + "LDAP UDP operations",
2998 + "operations/s",
2999 + PLUGIN_WINDOWS_NAME,
3000 + "PerflibAD",
3001 + PRIO_AD_LDAP_UDP_OPERATIONS_TOTAL,
3002 + update_every,
3003 + RRDSET_TYPE_LINE);
3004 +
3005 + rd_ldap_udp_operations_total =
3006 + rrddim_add(st_ldap_udp_operations_total, "udp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3007 + }
3008 +
3009 + rrddim_set_by_pointer(
3010 + st_ldap_udp_operations_total,
3011 + rd_ldap_udp_operations_total,
3012 + (collected_number)ldapUDPOperationsPerSec.current.Data);
3013 + rrdset_done(st_ldap_udp_operations_total);
3014 +}
3015 +
3016 +static void netdata_ad_ldap_writes(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3017 +{
3018 + static COUNTER_DATA ldapWritesPerSec = {.key = "LDAP Writes/sec"};
3019 + static RRDSET *st_ldap_writes_total = NULL;
3020 + static RRDDIM *rd_ldap_writes_total = NULL;
3021 +
3022 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapWritesPerSec))
3023 + return;
3024 +
3025 + if (unlikely(!st_ldap_writes_total)) {
3026 + st_ldap_writes_total = rrdset_create_localhost(
3027 + "ad",
3028 + "ldap_writes",
3029 + NULL,
3030 + "ldap",
3031 + "ad.ldap_writes",
3032 + "LDAP writes",
3033 + "writes/s",
3034 + PLUGIN_WINDOWS_NAME,
3035 + "PerflibAD",
3036 + PRIO_AD_LDAP_WRITES_TOTAL,
3037 + update_every,
3038 + RRDSET_TYPE_LINE);
3039 +
3040 + rd_ldap_writes_total = rrddim_add(st_ldap_writes_total, "writes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3041 + }
3042 +
3043 + rrddim_set_by_pointer(st_ldap_writes_total, rd_ldap_writes_total, (collected_number)ldapWritesPerSec.current.Data);
3044 + rrdset_done(st_ldap_writes_total);
3045 +}
3046 +
3047 +static void
3048 +netdata_ad_ldap_client_sessions(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3049 +{
3050 + static COUNTER_DATA ldapClientSessions = {.key = "LDAP Client Sessions"};
3051 + static RRDSET *st_ldap_client_sessions = NULL;
3052 + static RRDDIM *rd_ldap_client_sessions = NULL;
3053 +
3054 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapClientSessions))
3055 + return;
3056 +
3057 + if (unlikely(!st_ldap_client_sessions)) {
3058 + st_ldap_client_sessions = rrdset_create_localhost(
3059 + "ad",
3060 + "ldap_client_sessions",
3061 + NULL,
3062 + "ldap",
3063 + "ad.ldap_client_sessions",
3064 + "LDAP client sessions",
3065 + "sessions",
3066 + PLUGIN_WINDOWS_NAME,
3067 + "PerflibAD",
3068 + PRIO_AD_LDAP_CLIENT_SESSIONS,
3069 + update_every,
3070 + RRDSET_TYPE_LINE);
3071 +
3072 + rd_ldap_client_sessions = rrddim_add(st_ldap_client_sessions, "sessions", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3073 + }
3074 +
3075 + rrddim_set_by_pointer(
3076 + st_ldap_client_sessions, rd_ldap_client_sessions, (collected_number)ldapClientSessions.current.Data);
3077 + rrdset_done(st_ldap_client_sessions);
3078 +}
3079 +
3080 +static void netdata_ad_ldap(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3081 +{
3082 + netdata_ad_ldap_closed_connections(pDataBlock, pObjectType, update_every);
3083 + netdata_ad_ldap_opened_connections_ldap(pDataBlock, pObjectType, update_every);
3084 + netdata_ad_ldap_opened_connections_ldaps(pDataBlock, pObjectType, update_every);
3085 + netdata_ad_ldap_active_threads(pDataBlock, pObjectType, update_every);
3086 + netdata_ad_ldap_udp_operations(pDataBlock, pObjectType, update_every);
3087 + netdata_ad_ldap_writes(pDataBlock, pObjectType, update_every);
3088 + netdata_ad_ldap_client_sessions(pDataBlock, pObjectType, update_every);
3089 +}
3090 +
3091 +static void
3092 +netdata_ad_cleanup_link_values_cleaned(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3093 +{
3094 + static COUNTER_DATA linkValuesCleanedPerSec = {.key = "Link Values Cleaned/sec"};
3095 + static RRDSET *st_link_values_cleaned_total = NULL;
3096 + static RRDDIM *rd_link_values_cleaned_total = NULL;
3097 +
3098 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &linkValuesCleanedPerSec))
3099 + return;
3100 +
3101 + if (unlikely(!st_link_values_cleaned_total)) {
3102 + st_link_values_cleaned_total = rrdset_create_localhost(
3103 + "ad",
3104 + "link_values_cleaned",
3105 + NULL,
3106 + "cleanup",
3107 + "ad.link_values_cleaned",
3108 + "Link values cleaned",
3109 + "values/s",
3110 + PLUGIN_WINDOWS_NAME,
3111 + "PerflibAD",
3112 + PRIO_AD_LINK_VALUES_CLEANED_TOTAL,
3113 + update_every,
3114 + RRDSET_TYPE_LINE);
3115 +
3116 + rd_link_values_cleaned_total =
3117 + rrddim_add(st_link_values_cleaned_total, "cleaned", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3118 + }
3119 +
3120 + rrddim_set_by_pointer(
3121 + st_link_values_cleaned_total,
3122 + rd_link_values_cleaned_total,
3123 + (collected_number)linkValuesCleanedPerSec.current.Data);
3124 + rrdset_done(st_link_values_cleaned_total);
3125 +}
3126 +
3127 +static void
3128 +netdata_ad_cleanup_phantom_objects_cleaned(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3129 +{
3130 + static COUNTER_DATA phantomsCleanedPerSec = {.key = "Phantoms Cleaned/sec"};
3131 + static RRDSET *st_phantom_objects_cleaned_total = NULL;
3132 + static RRDDIM *rd_phantom_objects_cleaned_total = NULL;
3133 +
3134 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &phantomsCleanedPerSec))
3135 + return;
3136 +
3137 + if (unlikely(!st_phantom_objects_cleaned_total)) {
3138 + st_phantom_objects_cleaned_total = rrdset_create_localhost(
3139 + "ad",
3140 + "phantom_objects_cleaned",
3141 + NULL,
3142 + "cleanup",
3143 + "ad.phantom_objects_cleaned",
3144 + "Phantom objects cleaned",
3145 + "objects/s",
3146 + PLUGIN_WINDOWS_NAME,
3147 + "PerflibAD",
3148 + PRIO_AD_PHANTOM_OBJECTS_CLEANED_TOTAL,
3149 + update_every,
3150 + RRDSET_TYPE_LINE);
3151 +
3152 + rd_phantom_objects_cleaned_total =
3153 + rrddim_add(st_phantom_objects_cleaned_total, "cleaned", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3154 + }
3155 +
3156 + rrddim_set_by_pointer(
3157 + st_phantom_objects_cleaned_total,
3158 + rd_phantom_objects_cleaned_total,
3159 + (collected_number)phantomsCleanedPerSec.current.Data);
3160 + rrdset_done(st_phantom_objects_cleaned_total);
3161 +}
3162 +
3163 +static void
3164 +netdata_ad_cleanup_phantom_objects_visited(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3165 +{
3166 + static COUNTER_DATA phantomsVisitedPerSec = {.key = "Phantoms Visited/sec"};
3167 + static RRDSET *st_phantom_objects_visited_total = NULL;
3168 + static RRDDIM *rd_phantom_objects_visited_total = NULL;
3169 +
3170 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &phantomsVisitedPerSec))
3171 + return;
3172 +
3173 + if (unlikely(!st_phantom_objects_visited_total)) {
3174 + st_phantom_objects_visited_total = rrdset_create_localhost(
3175 + "ad",
3176 + "phantom_objects_visited",
3177 + NULL,
3178 + "cleanup",
3179 + "ad.phantom_objects_visited",
3180 + "Phantom objects visited",
3181 + "objects/s",
3182 + PLUGIN_WINDOWS_NAME,
3183 + "PerflibAD",
3184 + PRIO_AD_PHANTOM_OBJECTS_VISITED_TOTAL,
3185 + update_every,
3186 + RRDSET_TYPE_LINE);
3187 +
3188 + rd_phantom_objects_visited_total =
3189 + rrddim_add(st_phantom_objects_visited_total, "visited", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3190 + }
3191 +
3192 + rrddim_set_by_pointer(
3193 + st_phantom_objects_visited_total,
3194 + rd_phantom_objects_visited_total,
3195 + (collected_number)phantomsVisitedPerSec.current.Data);
3196 + rrdset_done(st_phantom_objects_visited_total);
3197 +}
3198 +
3199 +static void netdata_ad_cleanup_tombstoned_objects_collected(
3200 + PERF_DATA_BLOCK *pDataBlock,
3201 + PERF_OBJECT_TYPE *pObjectType,
3202 + int update_every)
3203 +{
3204 + static COUNTER_DATA tombstonesGarbageCollectedPerSec = {.key = "Tombstones Garbage Collected/sec"};
3205 + static RRDSET *st_tombstoned_objects_collected_total = NULL;
3206 + static RRDDIM *rd_tombstoned_objects_collected_total = NULL;
3207 +
3208 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &tombstonesGarbageCollectedPerSec))
3209 + return;
3210 +
3211 + if (unlikely(!st_tombstoned_objects_collected_total)) {
3212 + st_tombstoned_objects_collected_total = rrdset_create_localhost(
3213 + "ad",
3214 + "tombstoned_objects_collected",
3215 + NULL,
3216 + "cleanup",
3217 + "ad.tombstoned_objects_collected",
3218 + "Tombstoned objects collected",
3219 + "objects/s",
3220 + PLUGIN_WINDOWS_NAME,
3221 + "PerflibAD",
3222 + PRIO_AD_TOMBSTONED_OBJECTS_COLLECTED_TOTAL,
3223 + update_every,
3224 + RRDSET_TYPE_LINE);
3225 +
3226 + rd_tombstoned_objects_collected_total =
3227 + rrddim_add(st_tombstoned_objects_collected_total, "collected", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3228 + }
3229 +
3230 + rrddim_set_by_pointer(
3231 + st_tombstoned_objects_collected_total,
3232 + rd_tombstoned_objects_collected_total,
3233 + (collected_number)tombstonesGarbageCollectedPerSec.current.Data);
3234 + rrdset_done(st_tombstoned_objects_collected_total);
3235 +}
3236 +
3237 +static void netdata_ad_cleanup_tombstoned_objects_visited(
3238 + PERF_DATA_BLOCK *pDataBlock,
3239 + PERF_OBJECT_TYPE *pObjectType,
3240 + int update_every)
3241 +{
3242 + static COUNTER_DATA tombstonesVisitedPerSec = {.key = "Tombstones Visited/sec"};
3243 + static RRDSET *st_tombstoned_objects_visited_total = NULL;
3244 + static RRDDIM *rd_tombstoned_objects_visited_total = NULL;
3245 +
3246 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &tombstonesVisitedPerSec))
3247 + return;
3248 +
3249 + if (unlikely(!st_tombstoned_objects_visited_total)) {
3250 + st_tombstoned_objects_visited_total = rrdset_create_localhost(
3251 + "ad",
3252 + "tombstoned_objects_visited",
3253 + NULL,
3254 + "cleanup",
3255 + "ad.tombstoned_objects_visited",
3256 + "Tombstoned objects visited",
3257 + "objects/s",
3258 + PLUGIN_WINDOWS_NAME,
3259 + "PerflibAD",
3260 + PRIO_AD_TOMBSTONED_OBJECTS_VISITED_TOTAL,
3261 + update_every,
3262 + RRDSET_TYPE_LINE);
3263 +
3264 + rd_tombstoned_objects_visited_total =
3265 + rrddim_add(st_tombstoned_objects_visited_total, "visited", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3266 + }
3267 +
3268 + rrddim_set_by_pointer(
3269 + st_tombstoned_objects_visited_total,
3270 + rd_tombstoned_objects_visited_total,
3271 + (collected_number)tombstonesVisitedPerSec.current.Data);
3272 + rrdset_done(st_tombstoned_objects_visited_total);
3273 +}
3274 +
3275 +static void netdata_ad_cleanup_metrics(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3276 +{
3277 + netdata_ad_cleanup_link_values_cleaned(pDataBlock, pObjectType, update_every);
3278 + netdata_ad_cleanup_phantom_objects_cleaned(pDataBlock, pObjectType, update_every);
3279 + netdata_ad_cleanup_phantom_objects_visited(pDataBlock, pObjectType, update_every);
3280 + netdata_ad_cleanup_tombstoned_objects_collected(pDataBlock, pObjectType, update_every);
3281 + netdata_ad_cleanup_tombstoned_objects_visited(pDataBlock, pObjectType, update_every);
3282 +}
3283 +
3284 +static void
3285 +netdata_ad_sam_group_membership_evaluations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3286 +{
3287 + static COUNTER_DATA samGlobalGroupMembershipEvaluationsPerSec = {
3288 + .key = "SAM Global Group Membership Evaluations/sec"};
3289 + static COUNTER_DATA samDomainLocalGroupMembershipEvaluationsPerSec = {
3290 + .key = "SAM Domain Local Group Membership Evaluations/sec"};
3291 + static COUNTER_DATA samUniversalGroupMembershipEvaluationsPerSec = {
3292 + .key = "SAM Universal Group Membership Evaluations/sec"};
3293 +
3294 + static RRDSET *st_sam_group_membership_evaluations = NULL;
3295 + static RRDDIM *rd_sam_group_membership_evaluations_global = NULL;
3296 + static RRDDIM *rd_sam_group_membership_evaluations_domain_local = NULL;
3297 + static RRDDIM *rd_sam_group_membership_evaluations_universal = NULL;
3298 +
3299 + perflibGetObjectCounter(pDataBlock, pObjectType, &samGlobalGroupMembershipEvaluationsPerSec);
3300 + perflibGetObjectCounter(pDataBlock, pObjectType, &samDomainLocalGroupMembershipEvaluationsPerSec);
3301 + perflibGetObjectCounter(pDataBlock, pObjectType, &samUniversalGroupMembershipEvaluationsPerSec);
3302 +
3303 + if (unlikely(!st_sam_group_membership_evaluations)) {
3304 + st_sam_group_membership_evaluations = rrdset_create_localhost(
3305 + "ad",
3306 + "sam_group_membership_evaluations",
3307 NULL,
466 - "threads",
467 - "ad.ds_threads",
468 - "Directory Service threads",
469 - "threads",
3308 + "sam",
3309 + "ad.sam_group_membership_evaluations",
3310 + "SAM group membership evaluations",
3311 + "evaluations/s",
3312 PLUGIN_WINDOWS_NAME,
3313 "PerflibAD",
472 - PRIO_AD_THREADS_IN_USE,
3314 + PRIO_AD_SAM_GROUP_MEMBERSHIP_EVALUATIONS_TOTAL,
3315 update_every,
3316 RRDSET_TYPE_LINE);
3317
476 - rd_directory_services_threads =
477 - rrddim_add(st_directory_services_threads, "thread", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3318 + rd_sam_group_membership_evaluations_global =
3319 + rrddim_add(st_sam_group_membership_evaluations, "global", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3320 + rd_sam_group_membership_evaluations_domain_local =
3321 + rrddim_add(st_sam_group_membership_evaluations, "domain_local", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3322 + rd_sam_group_membership_evaluations_universal =
3323 + rrddim_add(st_sam_group_membership_evaluations, "universal", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3324 }
3325
3326 rrddim_set_by_pointer(
481 - st_directory_services_threads,
482 - rd_directory_services_threads,
483 - (collected_number)directoryServiceThreads.current.Data);
484 - rrdset_done(st_directory_services_threads);
3327 + st_sam_group_membership_evaluations,
3328 + rd_sam_group_membership_evaluations_global,
3329 + (collected_number)samGlobalGroupMembershipEvaluationsPerSec.current.Data);
3330 + rrddim_set_by_pointer(
3331 + st_sam_group_membership_evaluations,
3332 + rd_sam_group_membership_evaluations_domain_local,
3333 + (collected_number)samDomainLocalGroupMembershipEvaluationsPerSec.current.Data);
3334 + rrddim_set_by_pointer(
3335 + st_sam_group_membership_evaluations,
3336 + rd_sam_group_membership_evaluations_universal,
3337 + (collected_number)samUniversalGroupMembershipEvaluationsPerSec.current.Data);
3338 + rrdset_done(st_sam_group_membership_evaluations);
3339 }
3340
487 -static void netdata_ad_bind_time(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3341 +static void netdata_ad_sam_group_membership_global_catalog_evaluations(
3342 + PERF_DATA_BLOCK *pDataBlock,
3343 + PERF_OBJECT_TYPE *pObjectType,
3344 + int update_every)
3345 {
489 - static COUNTER_DATA ldapLastBindTimeSecondsTotal = {.key = "DAP Bind Time"};
490 - static RRDSET *st_ldap_last_bind_time_seconds_total = NULL;
491 - static RRDDIM *rd_ldap_last_bind_time_seconds_total = NULL;
3346 + static COUNTER_DATA samGCEvaluationsPerSec = {.key = "SAM GC Evaluations/sec"};
3347 + static RRDSET *st_sam_group_membership_global_catalog_evaluations = NULL;
3348 + static RRDDIM *rd_sam_group_membership_global_catalog_evaluations = NULL;
3349
493 - if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ldapLastBindTimeSecondsTotal)) {
3350 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samGCEvaluationsPerSec))
3351 return;
495 - }
3352
497 - if (unlikely(!st_ldap_last_bind_time_seconds_total)) {
498 - st_ldap_last_bind_time_seconds_total = rrdset_create_localhost(
3353 + if (unlikely(!st_sam_group_membership_global_catalog_evaluations)) {
3354 + st_sam_group_membership_global_catalog_evaluations = rrdset_create_localhost(
3355 "ad",
500 - "ldap_last_bind_time",
3356 + "sam_group_membership_global_catalog_evaluations",
3357 NULL,
502 - "bind",
503 - "ad.ldap_last_bind_time",
504 - "LDAP last successful bind time",
505 - "seconds",
3358 + "sam",
3359 + "ad.sam_group_membership_global_catalog_evaluations",
3360 + "SAM group membership global catalog evaluations",
3361 + "evaluations/s",
3362 PLUGIN_WINDOWS_NAME,
3363 "PerflibAD",
508 - PRIO_AD_BIND_TIME,
3364 + PRIO_AD_SAM_GROUP_MEMBERSHIP_GLOBAL_CATALOG_EVALUATIONS_TOTAL,
3365 update_every,
3366 RRDSET_TYPE_LINE);
3367
512 - rd_ldap_last_bind_time_seconds_total =
513 - rrddim_add(st_ldap_last_bind_time_seconds_total, "last_bind", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3368 + rd_sam_group_membership_global_catalog_evaluations = rrddim_add(
3369 + st_sam_group_membership_global_catalog_evaluations, "global_catalog", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3370 }
3371
3372 rrddim_set_by_pointer(
517 - st_ldap_last_bind_time_seconds_total,
518 - rd_ldap_last_bind_time_seconds_total,
519 - (collected_number)ldapLastBindTimeSecondsTotal.current.Data);
520 - rrdset_done(st_ldap_last_bind_time_seconds_total);
3373 + st_sam_group_membership_global_catalog_evaluations,
3374 + rd_sam_group_membership_global_catalog_evaluations,
3375 + (collected_number)samGCEvaluationsPerSec.current.Data);
3376 + rrdset_done(st_sam_group_membership_global_catalog_evaluations);
3377 }
3378
523 -static void netdata_ad_binds(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3379 +static void netdata_ad_sam_group_membership_evaluations_nontransitive(
3380 + PERF_DATA_BLOCK *pDataBlock,
3381 + PERF_OBJECT_TYPE *pObjectType,
3382 + int update_every)
3383 {
525 - static COUNTER_DATA bindsTotal = {.key = "DS Server Binds/sec"};
526 -
527 - static RRDSET *st_binds_total = NULL;
528 - static RRDDIM *rd_binds_total = NULL;
3384 + static COUNTER_DATA samNonTransitiveMembershipEvaluationsPerSec = {
3385 + .key = "SAM Non-Transitive Membership Evaluations/sec"};
3386 + static RRDSET *st_sam_group_membership_evaluations_nontransitive = NULL;
3387 + static RRDDIM *rd_sam_group_membership_evaluations_nontransitive = NULL;
3388
530 - if (perflibGetObjectCounter(pDataBlock, pObjectType, &bindsTotal)) {
531 - if (unlikely(!st_binds_total)) {
532 - st_binds_total = rrdset_create_localhost(
533 - "ad",
534 - "binds",
535 - NULL,
536 - "bind",
537 - "ad.binds",
538 - "Successful binds",
539 - "bind/s",
540 - PLUGIN_WINDOWS_NAME,
541 - "PerflibAD",
542 - PRIO_AD_BIND_TOTAL,
543 - update_every,
544 - RRDSET_TYPE_LINE);
3389 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samNonTransitiveMembershipEvaluationsPerSec))
3390 + return;
3391
546 - rd_binds_total = rrddim_add(st_binds_total, "binds", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
547 - }
3392 + if (unlikely(!st_sam_group_membership_evaluations_nontransitive)) {
3393 + st_sam_group_membership_evaluations_nontransitive = rrdset_create_localhost(
3394 + "ad",
3395 + "sam_group_membership_evaluations_nontransitive",
3396 + NULL,
3397 + "sam",
3398 + "ad.sam_group_membership_evaluations_nontransitive",
3399 + "SAM non-transitive membership evaluations",
3400 + "evaluations/s",
3401 + PLUGIN_WINDOWS_NAME,
3402 + "PerflibAD",
3403 + PRIO_AD_SAM_GROUP_MEMBERSHIP_EVALUATIONS_NONTRANSITIVE_TOTAL,
3404 + update_every,
3405 + RRDSET_TYPE_LINE);
3406
549 - rrddim_set_by_pointer(st_binds_total, rd_binds_total, (collected_number)bindsTotal.current.Data);
550 - rrdset_done(st_binds_total);
3407 + rd_sam_group_membership_evaluations_nontransitive = rrddim_add(
3408 + st_sam_group_membership_evaluations_nontransitive, "nontransitive", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3409 }
3410 +
3411 + rrddim_set_by_pointer(
3412 + st_sam_group_membership_evaluations_nontransitive,
3413 + rd_sam_group_membership_evaluations_nontransitive,
3414 + (collected_number)samNonTransitiveMembershipEvaluationsPerSec.current.Data);
3415 + rrdset_done(st_sam_group_membership_evaluations_nontransitive);
3416 }
3417
554 -static void netdata_ad_bind(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3418 +static void netdata_ad_sam_group_membership_evaluations_transitive(
3419 + PERF_DATA_BLOCK *pDataBlock,
3420 + PERF_OBJECT_TYPE *pObjectType,
3421 + int update_every)
3422 {
556 - netdata_ad_bind_time(pDataBlock, pObjectType, update_every);
557 - netdata_ad_binds(pDataBlock, pObjectType, update_every);
3423 + static COUNTER_DATA samTransitiveMembershipEvaluationsPerSec = {.key = "SAM Transitive Membership Evaluations/sec"};
3424 + static RRDSET *st_sam_group_membership_evaluations_transitive = NULL;
3425 + static RRDDIM *rd_sam_group_membership_evaluations_transitive = NULL;
3426 +
3427 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samTransitiveMembershipEvaluationsPerSec))
3428 + return;
3429 +
3430 + if (unlikely(!st_sam_group_membership_evaluations_transitive)) {
3431 + st_sam_group_membership_evaluations_transitive = rrdset_create_localhost(
3432 + "ad",
3433 + "sam_group_membership_evaluations_transitive",
3434 + NULL,
3435 + "sam",
3436 + "ad.sam_group_membership_evaluations_transitive",
3437 + "SAM transitive membership evaluations",
3438 + "evaluations/s",
3439 + PLUGIN_WINDOWS_NAME,
3440 + "PerflibAD",
3441 + PRIO_AD_SAM_GROUP_MEMBERSHIP_EVALUATIONS_TRANSITIVE_TOTAL,
3442 + update_every,
3443 + RRDSET_TYPE_LINE);
3444 +
3445 + rd_sam_group_membership_evaluations_transitive = rrddim_add(
3446 + st_sam_group_membership_evaluations_transitive, "transitive", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3447 + }
3448 +
3449 + rrddim_set_by_pointer(
3450 + st_sam_group_membership_evaluations_transitive,
3451 + rd_sam_group_membership_evaluations_transitive,
3452 + (collected_number)samTransitiveMembershipEvaluationsPerSec.current.Data);
3453 + rrdset_done(st_sam_group_membership_evaluations_transitive);
3454 }
3455
560 -/* TODO: Check why values are growing forever in our setup
561 -static void netdata_ad_atq_queue_requests(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3456 +static void
3457 +netdata_ad_sam_group_evaluation_latency(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3458 {
563 - static COUNTER_DATA atqOutstandingRequests = { .key = "ATQ Outstanding Queued Requests" };
564 - static RRDSET *st_atq_outstanding_requests = NULL;
565 - static RRDDIM *rd_atq_outstanding_requests = NULL;
3459 + static COUNTER_DATA samAccountGroupEvaluationLatency = {.key = "SAM Account Group Evaluation Latency"};
3460 + static COUNTER_DATA samResourceGroupEvaluationLatency = {.key = "SAM Resource Group Evaluation Latency"};
3461
567 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &atqOutstandingRequests)) {
568 - if (unlikely(!st_atq_outstanding_requests)) {
569 - st_atq_outstanding_requests = rrdset_create_localhost("ad"
570 - , "atq_outstanding_requests"
571 - , NULL
572 - , "queue"
573 - , "ad.atq_outstanding_requests"
574 - , "Outstanding requests"
575 - , "requests"
576 - , PLUGIN_WINDOWS_NAME
577 - , "PerflibAD"
578 - , PRIO_AD_OUTSTANDING_REQUEST
579 - , update_every
580 - , RRDSET_TYPE_LINE);
581 -
582 - rd_atq_outstanding_requests = rrddim_add(st_atq_outstanding_requests,
583 - "outstanding",
584 - NULL,
585 - 1,
586 - 1,
587 - RRD_ALGORITHM_ABSOLUTE);
588 - }
3462 + static RRDSET *st_sam_group_evaluation_latency = NULL;
3463 + static RRDDIM *rd_sam_group_evaluation_latency_account_group = NULL;
3464 + static RRDDIM *rd_sam_group_evaluation_latency_resource_group = NULL;
3465
590 - rrddim_set_by_pointer(st_atq_outstanding_requests,
591 - rd_atq_outstanding_requests,
592 - (collected_number)atqOutstandingRequests.current.Data);
593 - rrdset_done(st_atq_outstanding_requests);
3466 + perflibGetObjectCounter(pDataBlock, pObjectType, &samAccountGroupEvaluationLatency);
3467 + perflibGetObjectCounter(pDataBlock, pObjectType, &samResourceGroupEvaluationLatency);
3468 +
3469 + if (unlikely(!st_sam_group_evaluation_latency)) {
3470 + st_sam_group_evaluation_latency = rrdset_create_localhost(
3471 + "ad",
3472 + "sam_group_evaluation_latency",
3473 + NULL,
3474 + "sam",
3475 + "ad.sam_group_evaluation_latency",
3476 + "SAM group evaluation latency",
3477 + "latency",
3478 + PLUGIN_WINDOWS_NAME,
3479 + "PerflibAD",
3480 + PRIO_AD_SAM_GROUP_EVALUATION_LATENCY,
3481 + update_every,
3482 + RRDSET_TYPE_LINE);
3483 +
3484 + rd_sam_group_evaluation_latency_account_group =
3485 + rrddim_add(st_sam_group_evaluation_latency, "account_group", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3486 + rd_sam_group_evaluation_latency_resource_group =
3487 + rrddim_add(st_sam_group_evaluation_latency, "resource_group", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3488 }
3489 +
3490 + rrddim_set_by_pointer(
3491 + st_sam_group_evaluation_latency,
3492 + rd_sam_group_evaluation_latency_account_group,
3493 + (collected_number)samAccountGroupEvaluationLatency.current.Data);
3494 + rrddim_set_by_pointer(
3495 + st_sam_group_evaluation_latency,
3496 + rd_sam_group_evaluation_latency_resource_group,
3497 + (collected_number)samResourceGroupEvaluationLatency.current.Data);
3498 + rrdset_done(st_sam_group_evaluation_latency);
3499 }
596 - */
3500
598 -static void netdata_ad_atq_latency(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3501 +static void
3502 +netdata_ad_sam_computer_creation_requests(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3503 {
600 - static COUNTER_DATA atqAverageRequestLatency = {.key = "ATQ Request Latency"};
3504 + static COUNTER_DATA samMachineCreationAttemptsPerSec = {.key = "SAM Machine Creation Attempts/sec"};
3505 + static RRDSET *st_sam_computer_creation_requests = NULL;
3506 + static RRDDIM *rd_sam_computer_creation_requests = NULL;
3507
602 - static RRDSET *st_atq_average_request_latency = NULL;
603 - static RRDDIM *rd_atq_average_request_latency = NULL;
3508 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samMachineCreationAttemptsPerSec))
3509 + return;
3510
605 - if (!perflibGetObjectCounter(pDataBlock, pObjectType, &atqAverageRequestLatency))
3511 + if (unlikely(!st_sam_computer_creation_requests)) {
3512 + st_sam_computer_creation_requests = rrdset_create_localhost(
3513 + "ad",
3514 + "sam_computer_creation_requests",
3515 + NULL,
3516 + "sam",
3517 + "ad.sam_computer_creation_requests",
3518 + "SAM computer creation requests",
3519 + "requests/s",
3520 + PLUGIN_WINDOWS_NAME,
3521 + "PerflibAD",
3522 + PRIO_AD_SAM_COMPUTER_CREATION_REQUESTS_TOTAL,
3523 + update_every,
3524 + RRDSET_TYPE_LINE);
3525 +
3526 + rd_sam_computer_creation_requests =
3527 + rrddim_add(st_sam_computer_creation_requests, "request", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3528 + }
3529 +
3530 + rrddim_set_by_pointer(
3531 + st_sam_computer_creation_requests,
3532 + rd_sam_computer_creation_requests,
3533 + (collected_number)samMachineCreationAttemptsPerSec.current.Data);
3534 + rrdset_done(st_sam_computer_creation_requests);
3535 +}
3536 +
3537 +static void netdata_ad_sam_computer_creation_successful_requests(
3538 + PERF_DATA_BLOCK *pDataBlock,
3539 + PERF_OBJECT_TYPE *pObjectType,
3540 + int update_every)
3541 +{
3542 + static COUNTER_DATA samSuccessfulComputerCreationsPerSecIncludesAllRequests = {
3543 + .key = "SAM Successful Computer Creations/sec: Includes all requests"};
3544 + static RRDSET *st_sam_computer_creation_successful_requests = NULL;
3545 + static RRDDIM *rd_sam_computer_creation_successful_requests = NULL;
3546 +
3547 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samSuccessfulComputerCreationsPerSecIncludesAllRequests))
3548 return;
3549
608 - if (unlikely(!st_atq_average_request_latency)) {
609 - st_atq_average_request_latency = rrdset_create_localhost(
3550 + if (unlikely(!st_sam_computer_creation_successful_requests)) {
3551 + st_sam_computer_creation_successful_requests = rrdset_create_localhost(
3552 "ad",
611 - "atq_average_request_latency",
3553 + "sam_computer_creation_successful_requests",
3554 NULL,
613 - "queue",
614 - "ad.atq_average_request_latency",
615 - "Average request processing time",
616 - "seconds",
3555 + "sam",
3556 + "ad.sam_computer_creation_successful_requests",
3557 + "SAM successful computer creation requests",
3558 + "requests/s",
3559 PLUGIN_WINDOWS_NAME,
3560 "PerflibAD",
619 - PRIO_AD_AVG_REQUEST_LATENCY,
3561 + PRIO_AD_SAM_COMPUTER_CREATION_SUCCESSFUL_REQUESTS_TOTAL,
3562 update_every,
3563 RRDSET_TYPE_LINE);
3564
623 - rd_atq_average_request_latency =
624 - rrddim_add(st_atq_average_request_latency, "time", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
3565 + rd_sam_computer_creation_successful_requests =
3566 + rrddim_add(st_sam_computer_creation_successful_requests, "success", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3567 }
3568
3569 rrddim_set_by_pointer(
628 - st_atq_average_request_latency,
629 - rd_atq_average_request_latency,
630 - (collected_number)atqAverageRequestLatency.current.Data);
631 - rrdset_done(st_atq_average_request_latency);
3570 + st_sam_computer_creation_successful_requests,
3571 + rd_sam_computer_creation_successful_requests,
3572 + (collected_number)samSuccessfulComputerCreationsPerSecIncludesAllRequests.current.Data);
3573 + rrdset_done(st_sam_computer_creation_successful_requests);
3574 }
3575
634 -static void netdata_ad_op_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3576 +static void
3577 +netdata_ad_sam_user_creation_requests(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3578 {
636 - static COUNTER_DATA databaseAddsPerSec = {.key = "Database adds/sec"};
637 - static COUNTER_DATA databaseDeletesPerSec = {.key = "Database deletes/sec"};
638 - static COUNTER_DATA databaseModifiesPerSec = {.key = "Database modifys/sec"};
639 - static COUNTER_DATA databaseRecyclesPerSec = {.key = "Database recycles/sec"};
3579 + static COUNTER_DATA samUserCreationAttemptsPerSec = {.key = "SAM User Creation Attempts/sec"};
3580 + static RRDSET *st_sam_user_creation_requests = NULL;
3581 + static RRDDIM *rd_sam_user_creation_requests = NULL;
3582
641 - static RRDSET *st_database_operation_total = NULL;
642 - static RRDDIM *rd_database_operation_total_add = NULL;
643 - static RRDDIM *rd_database_operation_total_delete = NULL;
644 - static RRDDIM *rd_database_operation_total_modify = NULL;
645 - static RRDDIM *rd_database_operation_total_recycle = NULL;
3583 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samUserCreationAttemptsPerSec))
3584 + return;
3585
647 - perflibGetObjectCounter(pDataBlock, pObjectType, &databaseAddsPerSec);
648 - perflibGetObjectCounter(pDataBlock, pObjectType, &databaseDeletesPerSec);
649 - perflibGetObjectCounter(pDataBlock, pObjectType, &databaseModifiesPerSec);
650 - perflibGetObjectCounter(pDataBlock, pObjectType, &databaseRecyclesPerSec);
3586 + if (unlikely(!st_sam_user_creation_requests)) {
3587 + st_sam_user_creation_requests = rrdset_create_localhost(
3588 + "ad",
3589 + "sam_user_creation_requests",
3590 + NULL,
3591 + "sam",
3592 + "ad.sam_user_creation_requests",
3593 + "SAM user creation requests",
3594 + "requests/s",
3595 + PLUGIN_WINDOWS_NAME,
3596 + "PerflibAD",
3597 + PRIO_AD_SAM_USER_CREATION_REQUESTS_TOTAL,
3598 + update_every,
3599 + RRDSET_TYPE_LINE);
3600
652 - if (unlikely(!st_database_operation_total)) {
653 - st_database_operation_total = rrdset_create_localhost(
3601 + rd_sam_user_creation_requests =
3602 + rrddim_add(st_sam_user_creation_requests, "request", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3603 + }
3604 +
3605 + rrddim_set_by_pointer(
3606 + st_sam_user_creation_requests,
3607 + rd_sam_user_creation_requests,
3608 + (collected_number)samUserCreationAttemptsPerSec.current.Data);
3609 + rrdset_done(st_sam_user_creation_requests);
3610 +}
3611 +
3612 +static void netdata_ad_sam_user_creation_successful_requests(
3613 + PERF_DATA_BLOCK *pDataBlock,
3614 + PERF_OBJECT_TYPE *pObjectType,
3615 + int update_every)
3616 +{
3617 + static COUNTER_DATA samSuccessfulUserCreationsPerSec = {.key = "SAM Successful User Creations/sec"};
3618 + static RRDSET *st_sam_user_creation_successful_requests = NULL;
3619 + static RRDDIM *rd_sam_user_creation_successful_requests = NULL;
3620 +
3621 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samSuccessfulUserCreationsPerSec))
3622 + return;
3623 +
3624 + if (unlikely(!st_sam_user_creation_successful_requests)) {
3625 + st_sam_user_creation_successful_requests = rrdset_create_localhost(
3626 "ad",
655 - "database_operations",
3627 + "sam_user_creation_successful_requests",
3628 NULL,
657 - "database",
658 - "ad.database_operations",
659 - "AD database operations",
660 - "operations/s",
3629 + "sam",
3630 + "ad.sam_user_creation_successful_requests",
3631 + "SAM successful user creation requests",
3632 + "requests/s",
3633 PLUGIN_WINDOWS_NAME,
3634 "PerflibAD",
663 - PRIO_AD_OPERATIONS_TOTAL,
3635 + PRIO_AD_SAM_USER_CREATION_SUCCESSFUL_REQUESTS_TOTAL,
3636 update_every,
3637 RRDSET_TYPE_LINE);
3638
667 - rd_database_operation_total_add =
668 - rrddim_add(st_database_operation_total, "add", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3639 + rd_sam_user_creation_successful_requests =
3640 + rrddim_add(st_sam_user_creation_successful_requests, "success", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3641 + }
3642
670 - rd_database_operation_total_delete =
671 - rrddim_add(st_database_operation_total, "delete", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3643 + rrddim_set_by_pointer(
3644 + st_sam_user_creation_successful_requests,
3645 + rd_sam_user_creation_successful_requests,
3646 + (collected_number)samSuccessfulUserCreationsPerSec.current.Data);
3647 + rrdset_done(st_sam_user_creation_successful_requests);
3648 +}
3649
673 - rd_database_operation_total_modify =
674 - rrddim_add(st_database_operation_total, "modify", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3650 +static void
3651 +netdata_ad_sam_query_display_requests(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3652 +{
3653 + static COUNTER_DATA samDisplayInformationQueriesPerSec = {.key = "SAM Display Information Queries/sec"};
3654 + static RRDSET *st_sam_query_display_requests = NULL;
3655 + static RRDDIM *rd_sam_query_display_requests = NULL;
3656
676 - rd_database_operation_total_recycle =
677 - rrddim_add(st_database_operation_total, "recycle", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3657 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samDisplayInformationQueriesPerSec))
3658 + return;
3659 +
3660 + if (unlikely(!st_sam_query_display_requests)) {
3661 + st_sam_query_display_requests = rrdset_create_localhost(
3662 + "ad",
3663 + "sam_query_display_requests",
3664 + NULL,
3665 + "sam",
3666 + "ad.sam_query_display_requests",
3667 + "SAM query display requests",
3668 + "requests/s",
3669 + PLUGIN_WINDOWS_NAME,
3670 + "PerflibAD",
3671 + PRIO_AD_SAM_QUERY_DISPLAY_REQUESTS_TOTAL,
3672 + update_every,
3673 + RRDSET_TYPE_LINE);
3674 +
3675 + rd_sam_query_display_requests =
3676 + rrddim_add(st_sam_query_display_requests, "query", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3677 }
3678
3679 rrddim_set_by_pointer(
681 - st_database_operation_total,
682 - rd_database_operation_total_add,
683 - (collected_number)databaseAddsPerSec.current.Data);
3680 + st_sam_query_display_requests,
3681 + rd_sam_query_display_requests,
3682 + (collected_number)samDisplayInformationQueriesPerSec.current.Data);
3683 + rrdset_done(st_sam_query_display_requests);
3684 +}
3685 +
3686 +static void netdata_ad_sam_enumerations(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3687 +{
3688 + static COUNTER_DATA samEnumerationsPerSec = {.key = "SAM Enumerations/sec"};
3689 + static RRDSET *st_sam_enumerations = NULL;
3690 + static RRDDIM *rd_sam_enumerations = NULL;
3691 +
3692 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samEnumerationsPerSec))
3693 + return;
3694 +
3695 + if (unlikely(!st_sam_enumerations)) {
3696 + st_sam_enumerations = rrdset_create_localhost(
3697 + "ad",
3698 + "sam_enumerations",
3699 + NULL,
3700 + "sam",
3701 + "ad.sam_enumerations",
3702 + "SAM enumerations",
3703 + "enumerations/s",
3704 + PLUGIN_WINDOWS_NAME,
3705 + "PerflibAD",
3706 + PRIO_AD_SAM_ENUMERATIONS_TOTAL,
3707 + update_every,
3708 + RRDSET_TYPE_LINE);
3709 +
3710 + rd_sam_enumerations = rrddim_add(st_sam_enumerations, "enumeration", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3711 + }
3712
3713 rrddim_set_by_pointer(
686 - st_database_operation_total,
687 - rd_database_operation_total_delete,
688 - (collected_number)databaseDeletesPerSec.current.Data);
3714 + st_sam_enumerations, rd_sam_enumerations, (collected_number)samEnumerationsPerSec.current.Data);
3715 + rrdset_done(st_sam_enumerations);
3716 +}
3717 +
3718 +static void
3719 +netdata_ad_sam_membership_changes(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3720 +{
3721 + static COUNTER_DATA samMembershipChangesPerSec = {.key = "SAM Membership Changes/sec"};
3722 + static RRDSET *st_sam_membership_changes = NULL;
3723 + static RRDDIM *rd_sam_membership_changes = NULL;
3724 +
3725 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samMembershipChangesPerSec))
3726 + return;
3727 +
3728 + if (unlikely(!st_sam_membership_changes)) {
3729 + st_sam_membership_changes = rrdset_create_localhost(
3730 + "ad",
3731 + "sam_membership_changes",
3732 + NULL,
3733 + "sam",
3734 + "ad.sam_membership_changes",
3735 + "SAM membership changes",
3736 + "changes/s",
3737 + PLUGIN_WINDOWS_NAME,
3738 + "PerflibAD",
3739 + PRIO_AD_SAM_MEMBERSHIP_CHANGES_TOTAL,
3740 + update_every,
3741 + RRDSET_TYPE_LINE);
3742 +
3743 + rd_sam_membership_changes =
3744 + rrddim_add(st_sam_membership_changes, "change", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3745 + }
3746
3747 rrddim_set_by_pointer(
691 - st_database_operation_total,
692 - rd_database_operation_total_modify,
693 - (collected_number)databaseModifiesPerSec.current.Data);
3748 + st_sam_membership_changes,
3749 + rd_sam_membership_changes,
3750 + (collected_number)samMembershipChangesPerSec.current.Data);
3751 + rrdset_done(st_sam_membership_changes);
3752 +}
3753 +
3754 +static void
3755 +netdata_ad_sam_password_changes(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3756 +{
3757 + static COUNTER_DATA samPasswordChangesPerSec = {.key = "SAM Password Changes/sec"};
3758 + static RRDSET *st_sam_password_changes = NULL;
3759 + static RRDDIM *rd_sam_password_changes = NULL;
3760 +
3761 + if (!perflibGetObjectCounter(pDataBlock, pObjectType, &samPasswordChangesPerSec))
3762 + return;
3763 +
3764 + if (unlikely(!st_sam_password_changes)) {
3765 + st_sam_password_changes = rrdset_create_localhost(
3766 + "ad",
3767 + "sam_password_changes",
3768 + NULL,
3769 + "sam",
3770 + "ad.sam_password_changes",
3771 + "SAM password changes",
3772 + "changes/s",
3773 + PLUGIN_WINDOWS_NAME,
3774 + "PerflibAD",
3775 + PRIO_AD_SAM_PASSWORD_CHANGES_TOTAL,
3776 + update_every,
3777 + RRDSET_TYPE_LINE);
3778 +
3779 + rd_sam_password_changes = rrddim_add(st_sam_password_changes, "change", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3780 + }
3781
3782 rrddim_set_by_pointer(
696 - st_database_operation_total,
697 - rd_database_operation_total_recycle,
698 - (collected_number)databaseRecyclesPerSec.current.Data);
3783 + st_sam_password_changes, rd_sam_password_changes, (collected_number)samPasswordChangesPerSec.current.Data);
3784 + rrdset_done(st_sam_password_changes);
3785 +}
3786
700 - rrdset_done(st_database_operation_total);
3787 +static void netdata_ad_sam(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
3788 +{
3789 + netdata_ad_sam_group_membership_evaluations(pDataBlock, pObjectType, update_every);
3790 + netdata_ad_sam_group_membership_global_catalog_evaluations(pDataBlock, pObjectType, update_every);
3791 + netdata_ad_sam_group_membership_evaluations_nontransitive(pDataBlock, pObjectType, update_every);
3792 + netdata_ad_sam_group_membership_evaluations_transitive(pDataBlock, pObjectType, update_every);
3793 + netdata_ad_sam_group_evaluation_latency(pDataBlock, pObjectType, update_every);
3794 + netdata_ad_sam_computer_creation_requests(pDataBlock, pObjectType, update_every);
3795 + netdata_ad_sam_computer_creation_successful_requests(pDataBlock, pObjectType, update_every);
3796 + netdata_ad_sam_user_creation_requests(pDataBlock, pObjectType, update_every);
3797 + netdata_ad_sam_user_creation_successful_requests(pDataBlock, pObjectType, update_every);
3798 + netdata_ad_sam_query_display_requests(pDataBlock, pObjectType, update_every);
3799 + netdata_ad_sam_enumerations(pDataBlock, pObjectType, update_every);
3800 + netdata_ad_sam_membership_changes(pDataBlock, pObjectType, update_every);
3801 + netdata_ad_sam_password_changes(pDataBlock, pObjectType, update_every);
3802 }
3803
3804 static bool do_AD(PERF_DATA_BLOCK *pDataBlock, int update_every)
@@ -707,17 +3808,51 @@ static bool do_AD(PERF_DATA_BLOCK *pDataBlock, int update_every)
3808 return false;
3809
3810 static void (*doAD[])(PERF_DATA_BLOCK *, PERF_OBJECT_TYPE *, int) = {
3811 + netdata_ad_address_book,
3812 + netdata_ad_approximate_highest_dnt,
3813 netdata_ad_directory,
3814 + netdata_ad_search_scope,
3815 netdata_ad_cache_lookups,
3816 netdata_ad_properties,
3817 netdata_ad_compressed_traffic,
3818 + netdata_ad_replication_highest_usn,
3819 + netdata_ad_replication_inbound,
3820 netdata_ad_sync,
3821 + netdata_ad_replication_pending_operations,
3822 + netdata_ad_sync_result,
3823 netdata_ad_cache_hits,
3824 + netdata_ad_name_translations,
3825 + netdata_ad_change_monitors,
3826 + netdata_ad_directory_search_suboperations,
3827 + netdata_ad_security_descriptor_propagation,
3828 netdata_ad_service_threads_in_use,
3829 netdata_ad_bind,
3830 netdata_ad_searches,
3831 + netdata_ad_ldap,
3832 + netdata_ad_cleanup_metrics,
3833 + netdata_ad_sam,
3834 + netdata_ad_atq_queue_requests,
3835 + netdata_ad_atq_estimated_delay,
3836 netdata_ad_atq_latency,
3837 + netdata_ad_atq_current_threads,
3838 netdata_ad_op_total,
3839 + netdata_ad_directory_reads,
3840 + netdata_ad_directory_searches,
3841 + netdata_ad_directory_writes,
3842 + netdata_ad_replication_inbound_object_updates_remaining,
3843 + netdata_ad_replication_inbound_values_dns_only,
3844 + netdata_ad_replication_inbound_values_total,
3845 + netdata_ad_replication_outbound_objects_filtered,
3846 + netdata_ad_replication_outbound_objects,
3847 + netdata_ad_replication_outbound_properties,
3848 + netdata_ad_replication_outbound_values_dns_only,
3849 + netdata_ad_replication_outbound_values_total,
3850 + netdata_ad_replication_threads_getting_nc_changes,
3851 + netdata_ad_replication_threads_getting_nc_changes_holding_semaphore,
3852 + netdata_ad_transitive_operations,
3853 + netdata_ad_transitive_suboperations,
3854 + netdata_ad_replication_inbound_bytes_total,
3855 + netdata_ad_replication_outbound_bytes_total,
3856
3857 // This must be the end
3858 NULL};
src/collectors/windows.plugin/windows_plugin.h
+86 -2
@@ -142,7 +142,7 @@ enum PERFLIB_PRIO {
142 PRIO_AD_DIROPERATIONS_TOTAL,
143 PRIO_AD_CACHE_LOOKUP_TOTAL,
144 PRIO_AD_CACHE_HITS_TOTAL,
145 - PRIO_AD_REPLICATION_INTRASITE_COMPRESSED,
145 + PRIO_AD_REPLICATION_INTRASITE_UNCOMPRESSED,
146 PRIO_AD_REPLICATION_INTERSITE_COMPRESSED,
147 PRIO_AD_REPLICATION_PROPERTY_UPDATED,
148 PRIO_AD_REPLICATION_PROPERTY_FILTERED,
@@ -150,10 +150,94 @@ enum PERFLIB_PRIO {
150 PRIO_AD_SYNC_TOTAL,
151 PRIO_AD_THREADS_IN_USE,
152 PRIO_AD_BIND_TIME,
153 - PRIO_AD_BIND_TOTAL,
153 + PRIO_AD_BIND_DIGEST,
154 + PRIO_AD_BIND_DS_CLIENT,
155 + PRIO_AD_BIND_DS_SERVER,
156 + PRIO_AD_BIND_EXTERNAL,
157 + PRIO_AD_BIND_FAST,
158 + PRIO_AD_BIND_NEGOTIATE,
159 + PRIO_AD_BIND_NTLM,
160 + PRIO_AD_BIND_SIMPLE,
161 + PRIO_AD_BIND_LDAP,
162 PRIO_AD_LDAP_SEARCHES_TOTAL,
163 PRIO_AD_AVG_REQUEST_LATENCY,
164 PRIO_AD_OUTSTANDING_REQUEST,
165 + PRIO_AD_ADDRESS_BOOK_AMBIGUOUS_NAME_RESOLUTION,
166 + PRIO_AD_ADDRESS_BOOK_BROWSE,
167 + PRIO_AD_ADDRESS_BOOK_FIND,
168 + PRIO_AD_ADDRESS_BOOK_PROPERTY_READ,
169 + PRIO_AD_ADDRESS_BOOK_SEARCH,
170 + PRIO_AD_ADDRESS_BOOK_PROXY_SEARCH,
171 + PRIO_AD_ADDRESS_BOOK_CLIENT_SESSIONS,
172 + PRIO_AD_APPROXIMATE_HIGHEST_DNT,
173 + PRIO_AD_ATQ_ESTIMATED_DELAY,
174 + PRIO_AD_ATQ_CURRENT_THREADS_LDAP,
175 + PRIO_AD_ATQ_CURRENT_THREADS_OTHER,
176 + PRIO_AD_ATQ_CURRENT_THREADS_TOTAL,
177 + PRIO_AD_SEARCHES_SCOPE_BASE,
178 + PRIO_AD_SEARCHES_SCOPE_SUBTREE,
179 + PRIO_AD_SEARCHES_SCOPE_ONE_LEVEL,
180 + PRIO_AD_REPLICATION_HIGHEST_USN_COMMITTED,
181 + PRIO_AD_REPLICATION_HIGHEST_USN_ISSUED,
182 + PRIO_AD_REPLICATION_INBOUND_SYNC_OBJECTS_REMAINING,
183 + PRIO_AD_REPLICATION_INBOUND_LINK_VALUE_UPDATES_REMAINING,
184 + PRIO_AD_REPLICATION_INBOUND_OBJECTS_UPDATED,
185 + PRIO_AD_REPLICATION_INBOUND_OBJECTS_FILTERED,
186 + PRIO_AD_REPLICATION_PENDING_OPERATIONS,
187 + PRIO_AD_SYNC_SUCCESS_TOTAL,
188 + PRIO_AD_SYNC_SCHEMA_MISMATCH_FAILURE_TOTAL,
189 + PRIO_AD_NAME_TRANSLATIONS_CLIENT,
190 + PRIO_AD_NAME_TRANSLATIONS_SERVER,
191 + PRIO_AD_CHANGE_MONITORS_REGISTERED,
192 + PRIO_AD_CHANGE_MONITOR_UPDATES_PENDING,
193 + PRIO_AD_DIRECTORY_SEARCH_SUBOPERATIONS_TOTAL,
194 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_EVENTS_TOTAL,
195 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_EVENTS_QUEUED,
196 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_ACCESS_WAIT_TOTAL_SECONDS,
197 + PRIO_AD_SECURITY_DESCRIPTOR_PROPAGATION_ITEMS_QUEUED_TOTAL,
198 + PRIO_AD_LDAP_CLOSED_CONNECTIONS_TOTAL,
199 + PRIO_AD_LDAP_OPENED_CONNECTIONS_LDAP,
200 + PRIO_AD_LDAP_OPENED_CONNECTIONS_LDAPS,
201 + PRIO_AD_LDAP_ACTIVE_THREADS,
202 + PRIO_AD_LDAP_UDP_OPERATIONS_TOTAL,
203 + PRIO_AD_LDAP_WRITES_TOTAL,
204 + PRIO_AD_LDAP_CLIENT_SESSIONS,
205 + PRIO_AD_LINK_VALUES_CLEANED_TOTAL,
206 + PRIO_AD_PHANTOM_OBJECTS_CLEANED_TOTAL,
207 + PRIO_AD_PHANTOM_OBJECTS_VISITED_TOTAL,
208 + PRIO_AD_TOMBSTONED_OBJECTS_COLLECTED_TOTAL,
209 + PRIO_AD_TOMBSTONED_OBJECTS_VISITED_TOTAL,
210 + PRIO_AD_SAM_GROUP_MEMBERSHIP_EVALUATIONS_TOTAL,
211 + PRIO_AD_SAM_GROUP_MEMBERSHIP_GLOBAL_CATALOG_EVALUATIONS_TOTAL,
212 + PRIO_AD_SAM_GROUP_MEMBERSHIP_EVALUATIONS_NONTRANSITIVE_TOTAL,
213 + PRIO_AD_SAM_GROUP_MEMBERSHIP_EVALUATIONS_TRANSITIVE_TOTAL,
214 + PRIO_AD_SAM_GROUP_EVALUATION_LATENCY,
215 + PRIO_AD_SAM_COMPUTER_CREATION_REQUESTS_TOTAL,
216 + PRIO_AD_SAM_COMPUTER_CREATION_SUCCESSFUL_REQUESTS_TOTAL,
217 + PRIO_AD_SAM_USER_CREATION_REQUESTS_TOTAL,
218 + PRIO_AD_SAM_USER_CREATION_SUCCESSFUL_REQUESTS_TOTAL,
219 + PRIO_AD_SAM_QUERY_DISPLAY_REQUESTS_TOTAL,
220 + PRIO_AD_SAM_ENUMERATIONS_TOTAL,
221 + PRIO_AD_SAM_MEMBERSHIP_CHANGES_TOTAL,
222 + PRIO_AD_SAM_PASSWORD_CHANGES_TOTAL,
223 +
224 + PRIO_AD_DIRECTORY_READS,
225 + PRIO_AD_DIRECTORY_SEARCHES,
226 + PRIO_AD_DIRECTORY_WRITES,
227 + PRIO_AD_REPLICATION_INBOUND_OBJECT_UPDATES_REMAINING,
228 + PRIO_AD_REPLICATION_INBOUND_VALUES_DNS_ONLY,
229 + PRIO_AD_REPLICATION_INBOUND_VALUES_TOTAL,
230 + PRIO_AD_REPLICATION_OUTBOUND_OBJECTS_FILTERED,
231 + PRIO_AD_REPLICATION_OUTBOUND_OBJECTS,
232 + PRIO_AD_REPLICATION_OUTBOUND_PROPERTIES,
233 + PRIO_AD_REPLICATION_OUTBOUND_VALUES_DNS_ONLY,
234 + PRIO_AD_REPLICATION_OUTBOUND_VALUES_TOTAL,
235 + PRIO_AD_REPLICATION_THREADS_GETTING_NC_CHANGES,
236 + PRIO_AD_REPLICATION_THREADS_GETTING_NC_CHANGES_HOLDING_SEMAPHORE,
237 + PRIO_AD_TRANSITIVE_OPERATIONS,
238 + PRIO_AD_TRANSITIVE_SUBOPERATIONS,
239 + PRIO_AD_REPLICATION_INBOUND_BYTES_TOTAL,
240 + PRIO_AD_REPLICATION_OUTBOUND_BYTES_TOTAL,
241
242 PRIO_ADCS_CERT_REQUESTS_TOTAL,
243 PRIO_ADCS_CERT_REQUESTS_PROCESSING_TIME,