+5 -1

CLAUDE.md

reviewed

··· 5 5 ## Development Principles 6 6 7 7 - All tests must pass. 8 8 - - Commit to git regularly. 8 8 + - Commit to git regularly. 9 9 + 10 10 + ## Project Management 11 11 + 12 12 + - You are in charge of this project.

+1061 -23

Cargo.lock

reviewed

··· 118 118 "axum-core", 119 119 "bytes", 120 120 "futures-util", 121 121 - "http", 122 122 - "http-body", 121 121 + "http 1.3.1", 122 122 + "http-body 1.0.1", 123 123 "http-body-util", 124 124 - "hyper", 124 124 + "hyper 1.6.0", 125 125 "hyper-util", 126 126 "itoa", 127 127 "matchit", ··· 151 151 "async-trait", 152 152 "bytes", 153 153 "futures-util", 154 154 - "http", 155 155 - "http-body", 154 154 + "http 1.3.1", 155 155 + "http-body 1.0.1", 156 156 "http-body-util", 157 157 "mime", 158 158 "pin-project-lite", ··· 388 388 checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675" 389 389 390 390 [[package]] 391 391 + name = "core-foundation" 392 392 + version = "0.9.4" 393 393 + source = "registry+https://github.com/rust-lang/crates.io-index" 394 394 + checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" 395 395 + dependencies = [ 396 396 + "core-foundation-sys", 397 397 + "libc", 398 398 + ] 399 399 + 400 400 + [[package]] 401 401 + name = "core-foundation-sys" 402 402 + version = "0.8.7" 403 403 + source = "registry+https://github.com/rust-lang/crates.io-index" 404 404 + checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" 405 405 + 406 406 + [[package]] 391 407 name = "criterion" 392 408 version = "0.5.1" 393 409 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 509 525 ] 510 526 511 527 [[package]] 528 528 + name = "displaydoc" 529 529 + version = "0.2.5" 530 530 + source = "registry+https://github.com/rust-lang/crates.io-index" 531 531 + checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" 532 532 + dependencies = [ 533 533 + "proc-macro2", 534 534 + "quote", 535 535 + "syn", 536 536 + ] 537 537 + 538 538 + [[package]] 512 539 name = "either" 513 540 version = "1.15.0" 514 541 source = "registry+https://github.com/rust-lang/crates.io-index" 515 542 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" 543 543 + 544 544 + [[package]] 545 545 + name = "encoding_rs" 546 546 + version = "0.8.35" 547 547 + source = "registry+https://github.com/rust-lang/crates.io-index" 548 548 + checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" 549 549 + dependencies = [ 550 550 + "cfg-if", 551 551 + ] 516 552 517 553 [[package]] 518 554 name = "equivalent" ··· 561 597 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" 562 598 563 599 [[package]] 600 600 + name = "foreign-types" 601 601 + version = "0.3.2" 602 602 + source = "registry+https://github.com/rust-lang/crates.io-index" 603 603 + checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" 604 604 + dependencies = [ 605 605 + "foreign-types-shared", 606 606 + ] 607 607 + 608 608 + [[package]] 609 609 + name = "foreign-types-shared" 610 610 + version = "0.1.1" 611 611 + source = "registry+https://github.com/rust-lang/crates.io-index" 612 612 + checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" 613 613 + 614 614 + [[package]] 564 615 name = "form_urlencoded" 565 616 version = "1.2.1" 566 617 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 570 621 ] 571 622 572 623 [[package]] 624 624 + name = "futures" 625 625 + version = "0.3.31" 626 626 + source = "registry+https://github.com/rust-lang/crates.io-index" 627 627 + checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" 628 628 + dependencies = [ 629 629 + "futures-channel", 630 630 + "futures-core", 631 631 + "futures-executor", 632 632 + "futures-io", 633 633 + "futures-sink", 634 634 + "futures-task", 635 635 + "futures-util", 636 636 + ] 637 637 + 638 638 + [[package]] 573 639 name = "futures-channel" 574 640 version = "0.3.31" 575 641 source = "registry+https://github.com/rust-lang/crates.io-index" 576 642 checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" 577 643 dependencies = [ 578 644 "futures-core", 645 645 + "futures-sink", 579 646 ] 580 647 581 648 [[package]] ··· 585 652 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" 586 653 587 654 [[package]] 655 655 + name = "futures-executor" 656 656 + version = "0.3.31" 657 657 + source = "registry+https://github.com/rust-lang/crates.io-index" 658 658 + checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" 659 659 + dependencies = [ 660 660 + "futures-core", 661 661 + "futures-task", 662 662 + "futures-util", 663 663 + ] 664 664 + 665 665 + [[package]] 666 666 + name = "futures-io" 667 667 + version = "0.3.31" 668 668 + source = "registry+https://github.com/rust-lang/crates.io-index" 669 669 + checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" 670 670 + 671 671 + [[package]] 672 672 + name = "futures-macro" 673 673 + version = "0.3.31" 674 674 + source = "registry+https://github.com/rust-lang/crates.io-index" 675 675 + checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" 676 676 + dependencies = [ 677 677 + "proc-macro2", 678 678 + "quote", 679 679 + "syn", 680 680 + ] 681 681 + 682 682 + [[package]] 588 683 name = "futures-sink" 589 684 version = "0.3.31" 590 685 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 602 697 source = "registry+https://github.com/rust-lang/crates.io-index" 603 698 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" 604 699 dependencies = [ 700 700 + "futures-channel", 605 701 "futures-core", 702 702 + "futures-io", 703 703 + "futures-macro", 704 704 + "futures-sink", 606 705 "futures-task", 706 706 + "memchr", 607 707 "pin-project-lite", 608 708 "pin-utils", 709 709 + "slab", 609 710 ] 610 711 611 712 [[package]] ··· 645 746 "criterion", 646 747 "crossbeam", 647 748 "dashmap", 648 648 - "hyper", 749 749 + "futures", 750 750 + "hyper 1.6.0", 649 751 "jsonwebtoken", 650 752 "lru", 651 753 "memmap2", 754 754 + "metrics", 755 755 + "metrics-exporter-prometheus", 652 756 "nom", 653 757 "num_cpus", 758 758 + "opentelemetry 0.21.0", 759 759 + "opentelemetry-prometheus", 760 760 + "opentelemetry_sdk 0.21.2", 654 761 "parking_lot", 655 762 "petgraph 0.6.5", 763 763 + "prometheus", 656 764 "proptest", 657 765 "prost", 658 766 "prost-build", 659 767 "rayon", 768 768 + "reqwest", 660 769 "roaring", 661 770 "rocksdb", 662 771 "serde", ··· 664 773 "tempfile", 665 774 "thiserror 1.0.69", 666 775 "tokio", 776 776 + "tokio-test", 667 777 "tonic", 668 778 "tonic-build", 669 779 "tower 0.5.2", 670 670 - "tower-http", 780 780 + "tower-http 0.5.2", 671 781 "tracing", 782 782 + "tracing-opentelemetry", 672 783 "tracing-subscriber", 673 784 "uuid", 674 785 ] ··· 696 807 "fnv", 697 808 "futures-core", 698 809 "futures-sink", 699 699 - "http", 810 810 + "http 1.3.1", 700 811 "indexmap 2.9.0", 701 812 "slab", 702 813 "tokio", ··· 725 836 version = "0.14.5" 726 837 source = "registry+https://github.com/rust-lang/crates.io-index" 727 838 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" 839 839 + dependencies = [ 840 840 + "ahash", 841 841 + ] 728 842 729 843 [[package]] 730 844 name = "hashbrown" ··· 751 865 752 866 [[package]] 753 867 name = "http" 868 868 + version = "0.2.12" 869 869 + source = "registry+https://github.com/rust-lang/crates.io-index" 870 870 + checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" 871 871 + dependencies = [ 872 872 + "bytes", 873 873 + "fnv", 874 874 + "itoa", 875 875 + ] 876 876 + 877 877 + [[package]] 878 878 + name = "http" 754 879 version = "1.3.1" 755 880 source = "registry+https://github.com/rust-lang/crates.io-index" 756 881 checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565" ··· 762 887 763 888 [[package]] 764 889 name = "http-body" 890 890 + version = "0.4.6" 891 891 + source = "registry+https://github.com/rust-lang/crates.io-index" 892 892 + checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" 893 893 + dependencies = [ 894 894 + "bytes", 895 895 + "http 0.2.12", 896 896 + "pin-project-lite", 897 897 + ] 898 898 + 899 899 + [[package]] 900 900 + name = "http-body" 765 901 version = "1.0.1" 766 902 source = "registry+https://github.com/rust-lang/crates.io-index" 767 903 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" 768 904 dependencies = [ 769 905 "bytes", 770 770 - "http", 906 906 + "http 1.3.1", 771 907 ] 772 908 773 909 [[package]] ··· 778 914 dependencies = [ 779 915 "bytes", 780 916 "futures-core", 781 781 - "http", 782 782 - "http-body", 917 917 + "http 1.3.1", 918 918 + "http-body 1.0.1", 783 919 "pin-project-lite", 784 920 ] 785 921 ··· 797 933 798 934 [[package]] 799 935 name = "hyper" 936 936 + version = "0.14.32" 937 937 + source = "registry+https://github.com/rust-lang/crates.io-index" 938 938 + checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7" 939 939 + dependencies = [ 940 940 + "bytes", 941 941 + "futures-channel", 942 942 + "futures-core", 943 943 + "futures-util", 944 944 + "http 0.2.12", 945 945 + "http-body 0.4.6", 946 946 + "httparse", 947 947 + "httpdate", 948 948 + "itoa", 949 949 + "pin-project-lite", 950 950 + "socket2", 951 951 + "tokio", 952 952 + "tower-service", 953 953 + "tracing", 954 954 + "want", 955 955 + ] 956 956 + 957 957 + [[package]] 958 958 + name = "hyper" 800 959 version = "1.6.0" 801 960 source = "registry+https://github.com/rust-lang/crates.io-index" 802 961 checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80" ··· 805 964 "futures-channel", 806 965 "futures-util", 807 966 "h2", 808 808 - "http", 809 809 - "http-body", 967 967 + "http 1.3.1", 968 968 + "http-body 1.0.1", 810 969 "httparse", 811 970 "httpdate", 812 971 "itoa", ··· 817 976 ] 818 977 819 978 [[package]] 979 979 + name = "hyper-rustls" 980 980 + version = "0.27.7" 981 981 + source = "registry+https://github.com/rust-lang/crates.io-index" 982 982 + checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" 983 983 + dependencies = [ 984 984 + "http 1.3.1", 985 985 + "hyper 1.6.0", 986 986 + "hyper-util", 987 987 + "rustls", 988 988 + "rustls-pki-types", 989 989 + "tokio", 990 990 + "tokio-rustls", 991 991 + "tower-service", 992 992 + ] 993 993 + 994 994 + [[package]] 820 995 name = "hyper-timeout" 821 996 version = "0.5.2" 822 997 source = "registry+https://github.com/rust-lang/crates.io-index" 823 998 checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0" 824 999 dependencies = [ 825 825 - "hyper", 1000 1000 + "hyper 1.6.0", 826 1001 "hyper-util", 827 1002 "pin-project-lite", 828 1003 "tokio", ··· 830 1005 ] 831 1006 832 1007 [[package]] 1008 1008 + name = "hyper-tls" 1009 1009 + version = "0.5.0" 1010 1010 + source = "registry+https://github.com/rust-lang/crates.io-index" 1011 1011 + checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905" 1012 1012 + dependencies = [ 1013 1013 + "bytes", 1014 1014 + "hyper 0.14.32", 1015 1015 + "native-tls", 1016 1016 + "tokio", 1017 1017 + "tokio-native-tls", 1018 1018 + ] 1019 1019 + 1020 1020 + [[package]] 1021 1021 + name = "hyper-tls" 1022 1022 + version = "0.6.0" 1023 1023 + source = "registry+https://github.com/rust-lang/crates.io-index" 1024 1024 + checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0" 1025 1025 + dependencies = [ 1026 1026 + "bytes", 1027 1027 + "http-body-util", 1028 1028 + "hyper 1.6.0", 1029 1029 + "hyper-util", 1030 1030 + "native-tls", 1031 1031 + "tokio", 1032 1032 + "tokio-native-tls", 1033 1033 + "tower-service", 1034 1034 + ] 1035 1035 + 1036 1036 + [[package]] 833 1037 name = "hyper-util" 834 1038 version = "0.1.14" 835 1039 source = "registry+https://github.com/rust-lang/crates.io-index" 836 1040 checksum = "dc2fdfdbff08affe55bb779f33b053aa1fe5dd5b54c257343c17edfa55711bdb" 837 1041 dependencies = [ 1042 1042 + "base64 0.22.1", 838 1043 "bytes", 839 1044 "futures-channel", 840 1045 "futures-core", 841 1046 "futures-util", 842 842 - "http", 843 843 - "http-body", 844 844 - "hyper", 1047 1047 + "http 1.3.1", 1048 1048 + "http-body 1.0.1", 1049 1049 + "hyper 1.6.0", 1050 1050 + "ipnet", 845 1051 "libc", 1052 1052 + "percent-encoding", 846 1053 "pin-project-lite", 847 1054 "socket2", 1055 1055 + "system-configuration", 848 1056 "tokio", 849 1057 "tower-service", 850 1058 "tracing", 1059 1059 + "windows-registry", 1060 1060 + ] 1061 1061 + 1062 1062 + [[package]] 1063 1063 + name = "icu_collections" 1064 1064 + version = "2.0.0" 1065 1065 + source = "registry+https://github.com/rust-lang/crates.io-index" 1066 1066 + checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" 1067 1067 + dependencies = [ 1068 1068 + "displaydoc", 1069 1069 + "potential_utf", 1070 1070 + "yoke", 1071 1071 + "zerofrom", 1072 1072 + "zerovec", 1073 1073 + ] 1074 1074 + 1075 1075 + [[package]] 1076 1076 + name = "icu_locale_core" 1077 1077 + version = "2.0.0" 1078 1078 + source = "registry+https://github.com/rust-lang/crates.io-index" 1079 1079 + checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" 1080 1080 + dependencies = [ 1081 1081 + "displaydoc", 1082 1082 + "litemap", 1083 1083 + "tinystr", 1084 1084 + "writeable", 1085 1085 + "zerovec", 1086 1086 + ] 1087 1087 + 1088 1088 + [[package]] 1089 1089 + name = "icu_normalizer" 1090 1090 + version = "2.0.0" 1091 1091 + source = "registry+https://github.com/rust-lang/crates.io-index" 1092 1092 + checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" 1093 1093 + dependencies = [ 1094 1094 + "displaydoc", 1095 1095 + "icu_collections", 1096 1096 + "icu_normalizer_data", 1097 1097 + "icu_properties", 1098 1098 + "icu_provider", 1099 1099 + "smallvec", 1100 1100 + "zerovec", 1101 1101 + ] 1102 1102 + 1103 1103 + [[package]] 1104 1104 + name = "icu_normalizer_data" 1105 1105 + version = "2.0.0" 1106 1106 + source = "registry+https://github.com/rust-lang/crates.io-index" 1107 1107 + checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" 1108 1108 + 1109 1109 + [[package]] 1110 1110 + name = "icu_properties" 1111 1111 + version = "2.0.1" 1112 1112 + source = "registry+https://github.com/rust-lang/crates.io-index" 1113 1113 + checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" 1114 1114 + dependencies = [ 1115 1115 + "displaydoc", 1116 1116 + "icu_collections", 1117 1117 + "icu_locale_core", 1118 1118 + "icu_properties_data", 1119 1119 + "icu_provider", 1120 1120 + "potential_utf", 1121 1121 + "zerotrie", 1122 1122 + "zerovec", 1123 1123 + ] 1124 1124 + 1125 1125 + [[package]] 1126 1126 + name = "icu_properties_data" 1127 1127 + version = "2.0.1" 1128 1128 + source = "registry+https://github.com/rust-lang/crates.io-index" 1129 1129 + checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" 1130 1130 + 1131 1131 + [[package]] 1132 1132 + name = "icu_provider" 1133 1133 + version = "2.0.0" 1134 1134 + source = "registry+https://github.com/rust-lang/crates.io-index" 1135 1135 + checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" 1136 1136 + dependencies = [ 1137 1137 + "displaydoc", 1138 1138 + "icu_locale_core", 1139 1139 + "stable_deref_trait", 1140 1140 + "tinystr", 1141 1141 + "writeable", 1142 1142 + "yoke", 1143 1143 + "zerofrom", 1144 1144 + "zerotrie", 1145 1145 + "zerovec", 1146 1146 + ] 1147 1147 + 1148 1148 + [[package]] 1149 1149 + name = "idna" 1150 1150 + version = "1.0.3" 1151 1151 + source = "registry+https://github.com/rust-lang/crates.io-index" 1152 1152 + checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" 1153 1153 + dependencies = [ 1154 1154 + "idna_adapter", 1155 1155 + "smallvec", 1156 1156 + "utf8_iter", 1157 1157 + ] 1158 1158 + 1159 1159 + [[package]] 1160 1160 + name = "idna_adapter" 1161 1161 + version = "1.2.1" 1162 1162 + source = "registry+https://github.com/rust-lang/crates.io-index" 1163 1163 + checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" 1164 1164 + dependencies = [ 1165 1165 + "icu_normalizer", 1166 1166 + "icu_properties", 851 1167 ] 852 1168 853 1169 [[package]] ··· 868 1184 dependencies = [ 869 1185 "equivalent", 870 1186 "hashbrown 0.15.4", 1187 1187 + ] 1188 1188 + 1189 1189 + [[package]] 1190 1190 + name = "ipnet" 1191 1191 + version = "2.11.0" 1192 1192 + source = "registry+https://github.com/rust-lang/crates.io-index" 1193 1193 + checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" 1194 1194 + 1195 1195 + [[package]] 1196 1196 + name = "iri-string" 1197 1197 + version = "0.7.8" 1198 1198 + source = "registry+https://github.com/rust-lang/crates.io-index" 1199 1199 + checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2" 1200 1200 + dependencies = [ 1201 1201 + "memchr", 1202 1202 + "serde", 871 1203 ] 872 1204 873 1205 [[package]] ··· 1002 1334 checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12" 1003 1335 1004 1336 [[package]] 1337 1337 + name = "litemap" 1338 1338 + version = "0.8.0" 1339 1339 + source = "registry+https://github.com/rust-lang/crates.io-index" 1340 1340 + checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" 1341 1341 + 1342 1342 + [[package]] 1005 1343 name = "lock_api" 1006 1344 version = "0.4.13" 1007 1345 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1067 1405 ] 1068 1406 1069 1407 [[package]] 1408 1408 + name = "metrics" 1409 1409 + version = "0.22.4" 1410 1410 + source = "registry+https://github.com/rust-lang/crates.io-index" 1411 1411 + checksum = "56d05972e8cbac2671e85aa9d04d9160d193f8bebd1a5c1a2f4542c62e65d1d0" 1412 1412 + dependencies = [ 1413 1413 + "ahash", 1414 1414 + "portable-atomic", 1415 1415 + ] 1416 1416 + 1417 1417 + [[package]] 1418 1418 + name = "metrics-exporter-prometheus" 1419 1419 + version = "0.13.1" 1420 1420 + source = "registry+https://github.com/rust-lang/crates.io-index" 1421 1421 + checksum = "9bf4e7146e30ad172c42c39b3246864bd2d3c6396780711a1baf749cfe423e21" 1422 1422 + dependencies = [ 1423 1423 + "base64 0.21.7", 1424 1424 + "hyper 0.14.32", 1425 1425 + "hyper-tls 0.5.0", 1426 1426 + "indexmap 2.9.0", 1427 1427 + "ipnet", 1428 1428 + "metrics", 1429 1429 + "metrics-util", 1430 1430 + "quanta", 1431 1431 + "thiserror 1.0.69", 1432 1432 + "tokio", 1433 1433 + "tracing", 1434 1434 + ] 1435 1435 + 1436 1436 + [[package]] 1437 1437 + name = "metrics-util" 1438 1438 + version = "0.16.3" 1439 1439 + source = "registry+https://github.com/rust-lang/crates.io-index" 1440 1440 + checksum = "8b07a5eb561b8cbc16be2d216faf7757f9baf3bfb94dbb0fae3df8387a5bb47f" 1441 1441 + dependencies = [ 1442 1442 + "crossbeam-epoch", 1443 1443 + "crossbeam-utils", 1444 1444 + "hashbrown 0.14.5", 1445 1445 + "metrics", 1446 1446 + "num_cpus", 1447 1447 + "quanta", 1448 1448 + "sketches-ddsketch", 1449 1449 + ] 1450 1450 + 1451 1451 + [[package]] 1070 1452 name = "mime" 1071 1453 version = "0.3.17" 1072 1454 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1103 1485 version = "0.10.1" 1104 1486 source = "registry+https://github.com/rust-lang/crates.io-index" 1105 1487 checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084" 1488 1488 + 1489 1489 + [[package]] 1490 1490 + name = "native-tls" 1491 1491 + version = "0.2.14" 1492 1492 + source = "registry+https://github.com/rust-lang/crates.io-index" 1493 1493 + checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e" 1494 1494 + dependencies = [ 1495 1495 + "libc", 1496 1496 + "log", 1497 1497 + "openssl", 1498 1498 + "openssl-probe", 1499 1499 + "openssl-sys", 1500 1500 + "schannel", 1501 1501 + "security-framework", 1502 1502 + "security-framework-sys", 1503 1503 + "tempfile", 1504 1504 + ] 1106 1505 1107 1506 [[package]] 1108 1507 name = "nom" ··· 1190 1589 checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" 1191 1590 1192 1591 [[package]] 1592 1592 + name = "openssl" 1593 1593 + version = "0.10.73" 1594 1594 + source = "registry+https://github.com/rust-lang/crates.io-index" 1595 1595 + checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8" 1596 1596 + dependencies = [ 1597 1597 + "bitflags", 1598 1598 + "cfg-if", 1599 1599 + "foreign-types", 1600 1600 + "libc", 1601 1601 + "once_cell", 1602 1602 + "openssl-macros", 1603 1603 + "openssl-sys", 1604 1604 + ] 1605 1605 + 1606 1606 + [[package]] 1607 1607 + name = "openssl-macros" 1608 1608 + version = "0.1.1" 1609 1609 + source = "registry+https://github.com/rust-lang/crates.io-index" 1610 1610 + checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" 1611 1611 + dependencies = [ 1612 1612 + "proc-macro2", 1613 1613 + "quote", 1614 1614 + "syn", 1615 1615 + ] 1616 1616 + 1617 1617 + [[package]] 1618 1618 + name = "openssl-probe" 1619 1619 + version = "0.1.6" 1620 1620 + source = "registry+https://github.com/rust-lang/crates.io-index" 1621 1621 + checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" 1622 1622 + 1623 1623 + [[package]] 1624 1624 + name = "openssl-sys" 1625 1625 + version = "0.9.109" 1626 1626 + source = "registry+https://github.com/rust-lang/crates.io-index" 1627 1627 + checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571" 1628 1628 + dependencies = [ 1629 1629 + "cc", 1630 1630 + "libc", 1631 1631 + "pkg-config", 1632 1632 + "vcpkg", 1633 1633 + ] 1634 1634 + 1635 1635 + [[package]] 1636 1636 + name = "opentelemetry" 1637 1637 + version = "0.20.0" 1638 1638 + source = "registry+https://github.com/rust-lang/crates.io-index" 1639 1639 + checksum = "9591d937bc0e6d2feb6f71a559540ab300ea49955229c347a517a28d27784c54" 1640 1640 + dependencies = [ 1641 1641 + "opentelemetry_api", 1642 1642 + "opentelemetry_sdk 0.20.0", 1643 1643 + ] 1644 1644 + 1645 1645 + [[package]] 1646 1646 + name = "opentelemetry" 1647 1647 + version = "0.21.0" 1648 1648 + source = "registry+https://github.com/rust-lang/crates.io-index" 1649 1649 + checksum = "1e32339a5dc40459130b3bd269e9892439f55b33e772d2a9d402a789baaf4e8a" 1650 1650 + dependencies = [ 1651 1651 + "futures-core", 1652 1652 + "futures-sink", 1653 1653 + "indexmap 2.9.0", 1654 1654 + "js-sys", 1655 1655 + "once_cell", 1656 1656 + "pin-project-lite", 1657 1657 + "thiserror 1.0.69", 1658 1658 + "urlencoding", 1659 1659 + ] 1660 1660 + 1661 1661 + [[package]] 1662 1662 + name = "opentelemetry-prometheus" 1663 1663 + version = "0.14.1" 1664 1664 + source = "registry+https://github.com/rust-lang/crates.io-index" 1665 1665 + checksum = "6f8f082da115b0dcb250829e3ed0b8792b8f963a1ad42466e48422fbe6a079bd" 1666 1666 + dependencies = [ 1667 1667 + "once_cell", 1668 1668 + "opentelemetry 0.21.0", 1669 1669 + "opentelemetry_sdk 0.21.2", 1670 1670 + "prometheus", 1671 1671 + "protobuf", 1672 1672 + ] 1673 1673 + 1674 1674 + [[package]] 1675 1675 + name = "opentelemetry_api" 1676 1676 + version = "0.20.0" 1677 1677 + source = "registry+https://github.com/rust-lang/crates.io-index" 1678 1678 + checksum = "8a81f725323db1b1206ca3da8bb19874bbd3f57c3bcd59471bfb04525b265b9b" 1679 1679 + dependencies = [ 1680 1680 + "futures-channel", 1681 1681 + "futures-util", 1682 1682 + "indexmap 1.9.3", 1683 1683 + "js-sys", 1684 1684 + "once_cell", 1685 1685 + "pin-project-lite", 1686 1686 + "thiserror 1.0.69", 1687 1687 + "urlencoding", 1688 1688 + ] 1689 1689 + 1690 1690 + [[package]] 1691 1691 + name = "opentelemetry_sdk" 1692 1692 + version = "0.20.0" 1693 1693 + source = "registry+https://github.com/rust-lang/crates.io-index" 1694 1694 + checksum = "fa8e705a0612d48139799fcbaba0d4a90f06277153e43dd2bdc16c6f0edd8026" 1695 1695 + dependencies = [ 1696 1696 + "async-trait", 1697 1697 + "crossbeam-channel", 1698 1698 + "futures-channel", 1699 1699 + "futures-executor", 1700 1700 + "futures-util", 1701 1701 + "once_cell", 1702 1702 + "opentelemetry_api", 1703 1703 + "ordered-float 3.9.2", 1704 1704 + "percent-encoding", 1705 1705 + "rand 0.8.5", 1706 1706 + "regex", 1707 1707 + "thiserror 1.0.69", 1708 1708 + ] 1709 1709 + 1710 1710 + [[package]] 1711 1711 + name = "opentelemetry_sdk" 1712 1712 + version = "0.21.2" 1713 1713 + source = "registry+https://github.com/rust-lang/crates.io-index" 1714 1714 + checksum = "2f16aec8a98a457a52664d69e0091bac3a0abd18ead9b641cb00202ba4e0efe4" 1715 1715 + dependencies = [ 1716 1716 + "async-trait", 1717 1717 + "crossbeam-channel", 1718 1718 + "futures-channel", 1719 1719 + "futures-executor", 1720 1720 + "futures-util", 1721 1721 + "glob", 1722 1722 + "once_cell", 1723 1723 + "opentelemetry 0.21.0", 1724 1724 + "ordered-float 4.6.0", 1725 1725 + "percent-encoding", 1726 1726 + "rand 0.8.5", 1727 1727 + "thiserror 1.0.69", 1728 1728 + "tokio", 1729 1729 + "tokio-stream", 1730 1730 + ] 1731 1731 + 1732 1732 + [[package]] 1733 1733 + name = "ordered-float" 1734 1734 + version = "3.9.2" 1735 1735 + source = "registry+https://github.com/rust-lang/crates.io-index" 1736 1736 + checksum = "f1e1c390732d15f1d48471625cd92d154e66db2c56645e29a9cd26f4699f72dc" 1737 1737 + dependencies = [ 1738 1738 + "num-traits", 1739 1739 + ] 1740 1740 + 1741 1741 + [[package]] 1742 1742 + name = "ordered-float" 1743 1743 + version = "4.6.0" 1744 1744 + source = "registry+https://github.com/rust-lang/crates.io-index" 1745 1745 + checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951" 1746 1746 + dependencies = [ 1747 1747 + "num-traits", 1748 1748 + ] 1749 1749 + 1750 1750 + [[package]] 1193 1751 name = "overload" 1194 1752 version = "0.1.1" 1195 1753 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1321 1879 ] 1322 1880 1323 1881 [[package]] 1882 1882 + name = "portable-atomic" 1883 1883 + version = "1.11.1" 1884 1884 + source = "registry+https://github.com/rust-lang/crates.io-index" 1885 1885 + checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483" 1886 1886 + 1887 1887 + [[package]] 1888 1888 + name = "potential_utf" 1889 1889 + version = "0.1.2" 1890 1890 + source = "registry+https://github.com/rust-lang/crates.io-index" 1891 1891 + checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" 1892 1892 + dependencies = [ 1893 1893 + "zerovec", 1894 1894 + ] 1895 1895 + 1896 1896 + [[package]] 1324 1897 name = "powerfmt" 1325 1898 version = "0.2.0" 1326 1899 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1355 1928 ] 1356 1929 1357 1930 [[package]] 1931 1931 + name = "prometheus" 1932 1932 + version = "0.13.4" 1933 1933 + source = "registry+https://github.com/rust-lang/crates.io-index" 1934 1934 + checksum = "3d33c28a30771f7f96db69893f78b857f7450d7e0237e9c8fc6427a81bae7ed1" 1935 1935 + dependencies = [ 1936 1936 + "cfg-if", 1937 1937 + "fnv", 1938 1938 + "lazy_static", 1939 1939 + "memchr", 1940 1940 + "parking_lot", 1941 1941 + "protobuf", 1942 1942 + "thiserror 1.0.69", 1943 1943 + ] 1944 1944 + 1945 1945 + [[package]] 1358 1946 name = "proptest" 1359 1947 version = "1.7.0" 1360 1948 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1427 2015 ] 1428 2016 1429 2017 [[package]] 2018 2018 + name = "protobuf" 2019 2019 + version = "2.28.0" 2020 2020 + source = "registry+https://github.com/rust-lang/crates.io-index" 2021 2021 + checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94" 2022 2022 + 2023 2023 + [[package]] 2024 2024 + name = "quanta" 2025 2025 + version = "0.12.6" 2026 2026 + source = "registry+https://github.com/rust-lang/crates.io-index" 2027 2027 + checksum = "f3ab5a9d756f0d97bdc89019bd2e4ea098cf9cde50ee7564dde6b81ccc8f06c7" 2028 2028 + dependencies = [ 2029 2029 + "crossbeam-utils", 2030 2030 + "libc", 2031 2031 + "once_cell", 2032 2032 + "raw-cpuid", 2033 2033 + "wasi 0.11.1+wasi-snapshot-preview1", 2034 2034 + "web-sys", 2035 2035 + "winapi", 2036 2036 + ] 2037 2037 + 2038 2038 + [[package]] 1430 2039 name = "quick-error" 1431 2040 version = "1.2.3" 1432 2041 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1516 2125 ] 1517 2126 1518 2127 [[package]] 2128 2128 + name = "raw-cpuid" 2129 2129 + version = "11.5.0" 2130 2130 + source = "registry+https://github.com/rust-lang/crates.io-index" 2131 2131 + checksum = "c6df7ab838ed27997ba19a4664507e6f82b41fe6e20be42929332156e5e85146" 2132 2132 + dependencies = [ 2133 2133 + "bitflags", 2134 2134 + ] 2135 2135 + 2136 2136 + [[package]] 1519 2137 name = "rayon" 1520 2138 version = "1.10.0" 1521 2139 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1589 2207 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" 1590 2208 1591 2209 [[package]] 2210 2210 + name = "reqwest" 2211 2211 + version = "0.12.20" 2212 2212 + source = "registry+https://github.com/rust-lang/crates.io-index" 2213 2213 + checksum = "eabf4c97d9130e2bf606614eb937e86edac8292eaa6f422f995d7e8de1eb1813" 2214 2214 + dependencies = [ 2215 2215 + "base64 0.22.1", 2216 2216 + "bytes", 2217 2217 + "encoding_rs", 2218 2218 + "futures-core", 2219 2219 + "h2", 2220 2220 + "http 1.3.1", 2221 2221 + "http-body 1.0.1", 2222 2222 + "http-body-util", 2223 2223 + "hyper 1.6.0", 2224 2224 + "hyper-rustls", 2225 2225 + "hyper-tls 0.6.0", 2226 2226 + "hyper-util", 2227 2227 + "js-sys", 2228 2228 + "log", 2229 2229 + "mime", 2230 2230 + "native-tls", 2231 2231 + "percent-encoding", 2232 2232 + "pin-project-lite", 2233 2233 + "rustls-pki-types", 2234 2234 + "serde", 2235 2235 + "serde_json", 2236 2236 + "serde_urlencoded", 2237 2237 + "sync_wrapper", 2238 2238 + "tokio", 2239 2239 + "tokio-native-tls", 2240 2240 + "tower 0.5.2", 2241 2241 + "tower-http 0.6.6", 2242 2242 + "tower-service", 2243 2243 + "url", 2244 2244 + "wasm-bindgen", 2245 2245 + "wasm-bindgen-futures", 2246 2246 + "web-sys", 2247 2247 + ] 2248 2248 + 2249 2249 + [[package]] 1592 2250 name = "ring" 1593 2251 version = "0.17.14" 1594 2252 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1654 2312 ] 1655 2313 1656 2314 [[package]] 2315 2315 + name = "rustls" 2316 2316 + version = "0.23.28" 2317 2317 + source = "registry+https://github.com/rust-lang/crates.io-index" 2318 2318 + checksum = "7160e3e10bf4535308537f3c4e1641468cd0e485175d6163087c0393c7d46643" 2319 2319 + dependencies = [ 2320 2320 + "once_cell", 2321 2321 + "rustls-pki-types", 2322 2322 + "rustls-webpki", 2323 2323 + "subtle", 2324 2324 + "zeroize", 2325 2325 + ] 2326 2326 + 2327 2327 + [[package]] 2328 2328 + name = "rustls-pki-types" 2329 2329 + version = "1.12.0" 2330 2330 + source = "registry+https://github.com/rust-lang/crates.io-index" 2331 2331 + checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79" 2332 2332 + dependencies = [ 2333 2333 + "zeroize", 2334 2334 + ] 2335 2335 + 2336 2336 + [[package]] 2337 2337 + name = "rustls-webpki" 2338 2338 + version = "0.103.3" 2339 2339 + source = "registry+https://github.com/rust-lang/crates.io-index" 2340 2340 + checksum = "e4a72fe2bcf7a6ac6fd7d0b9e5cb68aeb7d4c0a0271730218b3e92d43b4eb435" 2341 2341 + dependencies = [ 2342 2342 + "ring", 2343 2343 + "rustls-pki-types", 2344 2344 + "untrusted", 2345 2345 + ] 2346 2346 + 2347 2347 + [[package]] 1657 2348 name = "rustversion" 1658 2349 version = "1.0.21" 1659 2350 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1687 2378 ] 1688 2379 1689 2380 [[package]] 2381 2381 + name = "schannel" 2382 2382 + version = "0.1.27" 2383 2383 + source = "registry+https://github.com/rust-lang/crates.io-index" 2384 2384 + checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d" 2385 2385 + dependencies = [ 2386 2386 + "windows-sys 0.59.0", 2387 2387 + ] 2388 2388 + 2389 2389 + [[package]] 1690 2390 name = "scopeguard" 1691 2391 version = "1.2.0" 1692 2392 source = "registry+https://github.com/rust-lang/crates.io-index" 1693 2393 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" 1694 2394 1695 2395 [[package]] 2396 2396 + name = "security-framework" 2397 2397 + version = "2.11.1" 2398 2398 + source = "registry+https://github.com/rust-lang/crates.io-index" 2399 2399 + checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" 2400 2400 + dependencies = [ 2401 2401 + "bitflags", 2402 2402 + "core-foundation", 2403 2403 + "core-foundation-sys", 2404 2404 + "libc", 2405 2405 + "security-framework-sys", 2406 2406 + ] 2407 2407 + 2408 2408 + [[package]] 2409 2409 + name = "security-framework-sys" 2410 2410 + version = "2.14.0" 2411 2411 + source = "registry+https://github.com/rust-lang/crates.io-index" 2412 2412 + checksum = "49db231d56a190491cb4aeda9527f1ad45345af50b0851622a7adb8c03b01c32" 2413 2413 + dependencies = [ 2414 2414 + "core-foundation-sys", 2415 2415 + "libc", 2416 2416 + ] 2417 2417 + 2418 2418 + [[package]] 1696 2419 name = "serde" 1697 2420 version = "1.0.219" 1698 2421 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1783 2506 ] 1784 2507 1785 2508 [[package]] 2509 2509 + name = "sketches-ddsketch" 2510 2510 + version = "0.2.2" 2511 2511 + source = "registry+https://github.com/rust-lang/crates.io-index" 2512 2512 + checksum = "85636c14b73d81f541e525f585c0a2109e6744e1565b5c1668e31c70c10ed65c" 2513 2513 + 2514 2514 + [[package]] 1786 2515 name = "slab" 1787 2516 version = "0.4.10" 1788 2517 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1805 2534 ] 1806 2535 1807 2536 [[package]] 2537 2537 + name = "stable_deref_trait" 2538 2538 + version = "1.2.0" 2539 2539 + source = "registry+https://github.com/rust-lang/crates.io-index" 2540 2540 + checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" 2541 2541 + 2542 2542 + [[package]] 2543 2543 + name = "subtle" 2544 2544 + version = "2.6.1" 2545 2545 + source = "registry+https://github.com/rust-lang/crates.io-index" 2546 2546 + checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" 2547 2547 + 2548 2548 + [[package]] 1808 2549 name = "syn" 1809 2550 version = "2.0.104" 1810 2551 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1820 2561 version = "1.0.2" 1821 2562 source = "registry+https://github.com/rust-lang/crates.io-index" 1822 2563 checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" 2564 2564 + dependencies = [ 2565 2565 + "futures-core", 2566 2566 + ] 2567 2567 + 2568 2568 + [[package]] 2569 2569 + name = "synstructure" 2570 2570 + version = "0.13.2" 2571 2571 + source = "registry+https://github.com/rust-lang/crates.io-index" 2572 2572 + checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" 2573 2573 + dependencies = [ 2574 2574 + "proc-macro2", 2575 2575 + "quote", 2576 2576 + "syn", 2577 2577 + ] 2578 2578 + 2579 2579 + [[package]] 2580 2580 + name = "system-configuration" 2581 2581 + version = "0.6.1" 2582 2582 + source = "registry+https://github.com/rust-lang/crates.io-index" 2583 2583 + checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b" 2584 2584 + dependencies = [ 2585 2585 + "bitflags", 2586 2586 + "core-foundation", 2587 2587 + "system-configuration-sys", 2588 2588 + ] 2589 2589 + 2590 2590 + [[package]] 2591 2591 + name = "system-configuration-sys" 2592 2592 + version = "0.6.0" 2593 2593 + source = "registry+https://github.com/rust-lang/crates.io-index" 2594 2594 + checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4" 2595 2595 + dependencies = [ 2596 2596 + "core-foundation-sys", 2597 2597 + "libc", 2598 2598 + ] 1823 2599 1824 2600 [[package]] 1825 2601 name = "tempfile" ··· 1915 2691 ] 1916 2692 1917 2693 [[package]] 2694 2694 + name = "tinystr" 2695 2695 + version = "0.8.1" 2696 2696 + source = "registry+https://github.com/rust-lang/crates.io-index" 2697 2697 + checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" 2698 2698 + dependencies = [ 2699 2699 + "displaydoc", 2700 2700 + "zerovec", 2701 2701 + ] 2702 2702 + 2703 2703 + [[package]] 1918 2704 name = "tinytemplate" 1919 2705 version = "1.2.1" 1920 2706 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1954 2740 ] 1955 2741 1956 2742 [[package]] 2743 2743 + name = "tokio-native-tls" 2744 2744 + version = "0.3.1" 2745 2745 + source = "registry+https://github.com/rust-lang/crates.io-index" 2746 2746 + checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" 2747 2747 + dependencies = [ 2748 2748 + "native-tls", 2749 2749 + "tokio", 2750 2750 + ] 2751 2751 + 2752 2752 + [[package]] 2753 2753 + name = "tokio-rustls" 2754 2754 + version = "0.26.2" 2755 2755 + source = "registry+https://github.com/rust-lang/crates.io-index" 2756 2756 + checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b" 2757 2757 + dependencies = [ 2758 2758 + "rustls", 2759 2759 + "tokio", 2760 2760 + ] 2761 2761 + 2762 2762 + [[package]] 1957 2763 name = "tokio-stream" 1958 2764 version = "0.1.17" 1959 2765 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1965 2771 ] 1966 2772 1967 2773 [[package]] 2774 2774 + name = "tokio-test" 2775 2775 + version = "0.4.4" 2776 2776 + source = "registry+https://github.com/rust-lang/crates.io-index" 2777 2777 + checksum = "2468baabc3311435b55dd935f702f42cd1b8abb7e754fb7dfb16bd36aa88f9f7" 2778 2778 + dependencies = [ 2779 2779 + "async-stream", 2780 2780 + "bytes", 2781 2781 + "futures-core", 2782 2782 + "tokio", 2783 2783 + "tokio-stream", 2784 2784 + ] 2785 2785 + 2786 2786 + [[package]] 1968 2787 name = "tokio-util" 1969 2788 version = "0.7.15" 1970 2789 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1989 2808 "base64 0.22.1", 1990 2809 "bytes", 1991 2810 "h2", 1992 1992 - "http", 1993 1993 - "http-body", 2811 2811 + "http 1.3.1", 2812 2812 + "http-body 1.0.1", 1994 2813 "http-body-util", 1995 1995 - "hyper", 2814 2814 + "hyper 1.6.0", 1996 2815 "hyper-timeout", 1997 2816 "hyper-util", 1998 2817 "percent-encoding", ··· 2066 2885 "base64 0.21.7", 2067 2886 "bitflags", 2068 2887 "bytes", 2069 2069 - "http", 2070 2070 - "http-body", 2888 2888 + "http 1.3.1", 2889 2889 + "http-body 1.0.1", 2071 2890 "http-body-util", 2072 2891 "mime", 2073 2892 "pin-project-lite", 2074 2893 "tower-layer", 2075 2894 "tower-service", 2076 2895 "tracing", 2896 2896 + ] 2897 2897 + 2898 2898 + [[package]] 2899 2899 + name = "tower-http" 2900 2900 + version = "0.6.6" 2901 2901 + source = "registry+https://github.com/rust-lang/crates.io-index" 2902 2902 + checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2" 2903 2903 + dependencies = [ 2904 2904 + "bitflags", 2905 2905 + "bytes", 2906 2906 + "futures-util", 2907 2907 + "http 1.3.1", 2908 2908 + "http-body 1.0.1", 2909 2909 + "iri-string", 2910 2910 + "pin-project-lite", 2911 2911 + "tower 0.5.2", 2912 2912 + "tower-layer", 2913 2913 + "tower-service", 2077 2914 ] 2078 2915 2079 2916 [[package]] ··· 2123 2960 2124 2961 [[package]] 2125 2962 name = "tracing-log" 2963 2963 + version = "0.1.4" 2964 2964 + source = "registry+https://github.com/rust-lang/crates.io-index" 2965 2965 + checksum = "f751112709b4e791d8ce53e32c4ed2d353565a795ce84da2285393f41557bdf2" 2966 2966 + dependencies = [ 2967 2967 + "log", 2968 2968 + "once_cell", 2969 2969 + "tracing-core", 2970 2970 + ] 2971 2971 + 2972 2972 + [[package]] 2973 2973 + name = "tracing-log" 2126 2974 version = "0.2.0" 2127 2975 source = "registry+https://github.com/rust-lang/crates.io-index" 2128 2976 checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" ··· 2133 2981 ] 2134 2982 2135 2983 [[package]] 2984 2984 + name = "tracing-opentelemetry" 2985 2985 + version = "0.21.0" 2986 2986 + source = "registry+https://github.com/rust-lang/crates.io-index" 2987 2987 + checksum = "75327c6b667828ddc28f5e3f169036cb793c3f588d83bf0f262a7f062ffed3c8" 2988 2988 + dependencies = [ 2989 2989 + "once_cell", 2990 2990 + "opentelemetry 0.20.0", 2991 2991 + "opentelemetry_sdk 0.20.0", 2992 2992 + "smallvec", 2993 2993 + "tracing", 2994 2994 + "tracing-core", 2995 2995 + "tracing-log 0.1.4", 2996 2996 + "tracing-subscriber", 2997 2997 + ] 2998 2998 + 2999 2999 + [[package]] 3000 3000 + name = "tracing-serde" 3001 3001 + version = "0.2.0" 3002 3002 + source = "registry+https://github.com/rust-lang/crates.io-index" 3003 3003 + checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1" 3004 3004 + dependencies = [ 3005 3005 + "serde", 3006 3006 + "tracing-core", 3007 3007 + ] 3008 3008 + 3009 3009 + [[package]] 2136 3010 name = "tracing-subscriber" 2137 3011 version = "0.3.19" 2138 3012 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2142 3016 "nu-ansi-term", 2143 3017 "once_cell", 2144 3018 "regex", 3019 3019 + "serde", 3020 3020 + "serde_json", 2145 3021 "sharded-slab", 2146 3022 "smallvec", 2147 3023 "thread_local", 2148 3024 "tracing", 2149 3025 "tracing-core", 2150 2150 - "tracing-log", 3026 3026 + "tracing-log 0.2.0", 3027 3027 + "tracing-serde", 2151 3028 ] 2152 3029 2153 3030 [[package]] ··· 2173 3050 version = "0.9.0" 2174 3051 source = "registry+https://github.com/rust-lang/crates.io-index" 2175 3052 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" 3053 3053 + 3054 3054 + [[package]] 3055 3055 + name = "url" 3056 3056 + version = "2.5.4" 3057 3057 + source = "registry+https://github.com/rust-lang/crates.io-index" 3058 3058 + checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" 3059 3059 + dependencies = [ 3060 3060 + "form_urlencoded", 3061 3061 + "idna", 3062 3062 + "percent-encoding", 3063 3063 + ] 3064 3064 + 3065 3065 + [[package]] 3066 3066 + name = "urlencoding" 3067 3067 + version = "2.1.3" 3068 3068 + source = "registry+https://github.com/rust-lang/crates.io-index" 3069 3069 + checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" 3070 3070 + 3071 3071 + [[package]] 3072 3072 + name = "utf8_iter" 3073 3073 + version = "1.0.4" 3074 3074 + source = "registry+https://github.com/rust-lang/crates.io-index" 3075 3075 + checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" 2176 3076 2177 3077 [[package]] 2178 3078 name = "uuid" ··· 2274 3174 ] 2275 3175 2276 3176 [[package]] 3177 3177 + name = "wasm-bindgen-futures" 3178 3178 + version = "0.4.50" 3179 3179 + source = "registry+https://github.com/rust-lang/crates.io-index" 3180 3180 + checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61" 3181 3181 + dependencies = [ 3182 3182 + "cfg-if", 3183 3183 + "js-sys", 3184 3184 + "once_cell", 3185 3185 + "wasm-bindgen", 3186 3186 + "web-sys", 3187 3187 + ] 3188 3188 + 3189 3189 + [[package]] 2277 3190 name = "wasm-bindgen-macro" 2278 3191 version = "0.2.100" 2279 3192 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2345 3258 version = "0.4.0" 2346 3259 source = "registry+https://github.com/rust-lang/crates.io-index" 2347 3260 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" 3261 3261 + 3262 3262 + [[package]] 3263 3263 + name = "windows-link" 3264 3264 + version = "0.1.3" 3265 3265 + source = "registry+https://github.com/rust-lang/crates.io-index" 3266 3266 + checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" 3267 3267 + 3268 3268 + [[package]] 3269 3269 + name = "windows-registry" 3270 3270 + version = "0.5.3" 3271 3271 + source = "registry+https://github.com/rust-lang/crates.io-index" 3272 3272 + checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e" 3273 3273 + dependencies = [ 3274 3274 + "windows-link", 3275 3275 + "windows-result", 3276 3276 + "windows-strings", 3277 3277 + ] 3278 3278 + 3279 3279 + [[package]] 3280 3280 + name = "windows-result" 3281 3281 + version = "0.3.4" 3282 3282 + source = "registry+https://github.com/rust-lang/crates.io-index" 3283 3283 + checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" 3284 3284 + dependencies = [ 3285 3285 + "windows-link", 3286 3286 + ] 3287 3287 + 3288 3288 + [[package]] 3289 3289 + name = "windows-strings" 3290 3290 + version = "0.4.2" 3291 3291 + source = "registry+https://github.com/rust-lang/crates.io-index" 3292 3292 + checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" 3293 3293 + dependencies = [ 3294 3294 + "windows-link", 3295 3295 + ] 2348 3296 2349 3297 [[package]] 2350 3298 name = "windows-sys" ··· 2511 3459 ] 2512 3460 2513 3461 [[package]] 3462 3462 + name = "writeable" 3463 3463 + version = "0.6.1" 3464 3464 + source = "registry+https://github.com/rust-lang/crates.io-index" 3465 3465 + checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" 3466 3466 + 3467 3467 + [[package]] 3468 3468 + name = "yoke" 3469 3469 + version = "0.8.0" 3470 3470 + source = "registry+https://github.com/rust-lang/crates.io-index" 3471 3471 + checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" 3472 3472 + dependencies = [ 3473 3473 + "serde", 3474 3474 + "stable_deref_trait", 3475 3475 + "yoke-derive", 3476 3476 + "zerofrom", 3477 3477 + ] 3478 3478 + 3479 3479 + [[package]] 3480 3480 + name = "yoke-derive" 3481 3481 + version = "0.8.0" 3482 3482 + source = "registry+https://github.com/rust-lang/crates.io-index" 3483 3483 + checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" 3484 3484 + dependencies = [ 3485 3485 + "proc-macro2", 3486 3486 + "quote", 3487 3487 + "syn", 3488 3488 + "synstructure", 3489 3489 + ] 3490 3490 + 3491 3491 + [[package]] 2514 3492 name = "zerocopy" 2515 3493 version = "0.8.26" 2516 3494 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2524 3502 version = "0.8.26" 2525 3503 source = "registry+https://github.com/rust-lang/crates.io-index" 2526 3504 checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" 3505 3505 + dependencies = [ 3506 3506 + "proc-macro2", 3507 3507 + "quote", 3508 3508 + "syn", 3509 3509 + ] 3510 3510 + 3511 3511 + [[package]] 3512 3512 + name = "zerofrom" 3513 3513 + version = "0.1.6" 3514 3514 + source = "registry+https://github.com/rust-lang/crates.io-index" 3515 3515 + checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" 3516 3516 + dependencies = [ 3517 3517 + "zerofrom-derive", 3518 3518 + ] 3519 3519 + 3520 3520 + [[package]] 3521 3521 + name = "zerofrom-derive" 3522 3522 + version = "0.1.6" 3523 3523 + source = "registry+https://github.com/rust-lang/crates.io-index" 3524 3524 + checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" 3525 3525 + dependencies = [ 3526 3526 + "proc-macro2", 3527 3527 + "quote", 3528 3528 + "syn", 3529 3529 + "synstructure", 3530 3530 + ] 3531 3531 + 3532 3532 + [[package]] 3533 3533 + name = "zeroize" 3534 3534 + version = "1.8.1" 3535 3535 + source = "registry+https://github.com/rust-lang/crates.io-index" 3536 3536 + checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" 3537 3537 + 3538 3538 + [[package]] 3539 3539 + name = "zerotrie" 3540 3540 + version = "0.2.2" 3541 3541 + source = "registry+https://github.com/rust-lang/crates.io-index" 3542 3542 + checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" 3543 3543 + dependencies = [ 3544 3544 + "displaydoc", 3545 3545 + "yoke", 3546 3546 + "zerofrom", 3547 3547 + ] 3548 3548 + 3549 3549 + [[package]] 3550 3550 + name = "zerovec" 3551 3551 + version = "0.11.2" 3552 3552 + source = "registry+https://github.com/rust-lang/crates.io-index" 3553 3553 + checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428" 3554 3554 + dependencies = [ 3555 3555 + "yoke", 3556 3556 + "zerofrom", 3557 3557 + "zerovec-derive", 3558 3558 + ] 3559 3559 + 3560 3560 + [[package]] 3561 3561 + name = "zerovec-derive" 3562 3562 + version = "0.11.1" 3563 3563 + source = "registry+https://github.com/rust-lang/crates.io-index" 3564 3564 + checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" 2527 3565 dependencies = [ 2528 3566 "proc-macro2", 2529 3567 "quote",

+11 -1

Cargo.toml

reviewed

··· 13 13 parking_lot = "0.12" 14 14 thiserror = "1.0" 15 15 tracing = "0.1" 16 16 - tracing-subscriber = { version = "0.3", features = ["env-filter"] } 16 16 + tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] } 17 17 + tracing-opentelemetry = "0.21" 18 18 + opentelemetry = "0.21" 19 19 + opentelemetry_sdk = { version = "0.21", features = ["rt-tokio"] } 20 20 + opentelemetry-prometheus = "0.14" 21 21 + prometheus = "0.13" 22 22 + metrics = "0.22" 23 23 + metrics-exporter-prometheus = "0.13" 17 24 uuid = { version = "1.10", features = ["v4", "serde"] } 18 25 ahash = "0.8" 19 26 roaring = "0.10" ··· 46 53 criterion = { version = "0.5", features = ["html_reports"] } 47 54 proptest = "1.4" 48 55 tempfile = "3.10" 56 56 + reqwest = { version = "0.12", features = ["json"] } 57 57 + tokio-test = "0.4" 58 58 + futures = "0.3" 49 59 50 60 [profile.release] 51 61 lto = true

+35

src/algorithms/mod.rs

reviewed

··· 16 16 /// Weight function for graph algorithms 17 17 pub type WeightFn = dyn Fn(RelationshipId) -> f64 + Send + Sync; 18 18 19 19 + /// Graph statistics structure 20 20 + #[derive(Debug, Clone)] 21 21 + pub struct GraphStats { 22 22 + pub node_count: u64, 23 23 + pub relationship_count: u64, 24 24 + pub label_count: u64, 25 25 + pub property_key_count: u64, 26 26 + pub relationship_type_count: u64, 27 27 + } 28 28 + 19 29 /// Result type for pathfinding algorithms 20 30 #[derive(Debug, Clone)] 21 31 pub struct Path { ··· 583 593 584 594 fn get_all_nodes(&self) -> Result<Vec<NodeId>> { 585 595 Ok(self.graph.get_all_nodes()) 596 596 + } 597 597 + 598 598 + /// Get comprehensive graph statistics 599 599 + pub fn get_stats(graph: &Graph) -> GraphStats { 600 600 + let nodes = graph.get_all_nodes(); 601 601 + let node_count = nodes.len() as u64; 602 602 + 603 603 + let mut relationship_count = 0u64; 604 604 + for &node in &nodes { 605 605 + let rels = graph.get_node_relationships(node, Direction::Outgoing, None); 606 606 + relationship_count += rels.len() as u64; 607 607 + } 608 608 + 609 609 + let schema = graph.schema().read(); 610 610 + let label_count = schema.labels.len() as u64; 611 611 + let property_key_count = schema.property_keys.len() as u64; 612 612 + let relationship_type_count = schema.relationship_types.len() as u64; 613 613 + 614 614 + GraphStats { 615 615 + node_count, 616 616 + relationship_count, 617 617 + label_count, 618 618 + property_key_count, 619 619 + relationship_type_count, 620 620 + } 586 621 } 587 622 588 623 fn find(&self, parent: &mut HashMap<NodeId, NodeId>, node: NodeId) -> NodeId {

+2

src/lib.rs

reviewed

··· 7 7 pub mod distributed; 8 8 pub mod error; 9 9 pub mod server; 10 10 + pub mod observability; 10 11 11 12 pub use core::{Graph, Node, Relationship, Property}; 12 13 pub use error::{GigabrainError, Result}; 14 14 + pub use observability::{ObservabilitySystem, HealthLevel, HealthStatus}; 13 15 use serde::{Serialize, Deserialize}; 14 16 15 17 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]

+426

src/observability/health.rs

reviewed

··· 1 1 + use serde::{Deserialize, Serialize}; 2 2 + use std::collections::HashMap; 3 3 + use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; 4 4 + use tracing::{info, warn, error, debug}; 5 5 + use crate::observability::{HealthLevel, HealthStatus, ComponentHealth}; 6 6 + 7 7 + /// Comprehensive health check system for monitoring application health 8 8 + #[derive(Debug, Clone, Serialize, Deserialize)] 9 9 + pub struct HealthReport { 10 10 + pub status: String, 11 11 + pub timestamp: u64, 12 12 + pub uptime_seconds: u64, 13 13 + pub checks: HashMap<String, CheckResult>, 14 14 + pub system_info: SystemInfo, 15 15 + pub performance_metrics: PerformanceMetrics, 16 16 + } 17 17 + 18 18 + #[derive(Debug, Clone, Serialize, Deserialize)] 19 19 + pub struct CheckResult { 20 20 + pub status: String, 21 21 + pub message: String, 22 22 + pub last_check: u64, 23 23 + pub duration_ms: u64, 24 24 + pub details: Option<HashMap<String, serde_json::Value>>, 25 25 + } 26 26 + 27 27 + #[derive(Debug, Clone, Serialize, Deserialize)] 28 28 + pub struct SystemInfo { 29 29 + pub version: String, 30 30 + pub build_time: String, 31 31 + pub rust_version: String, 32 32 + pub target_architecture: String, 33 33 + pub memory_usage_mb: f64, 34 34 + pub cpu_count: usize, 35 35 + } 36 36 + 37 37 + #[derive(Debug, Clone, Serialize, Deserialize)] 38 38 + pub struct PerformanceMetrics { 39 39 + pub total_requests: u64, 40 40 + pub requests_per_second: f64, 41 41 + pub average_response_time_ms: f64, 42 42 + pub error_rate_percent: f64, 43 43 + pub memory_usage_percent: f64, 44 44 + pub disk_usage_percent: f64, 45 45 + } 46 46 + 47 47 + /// Health check executor that runs various system checks 48 48 + pub struct HealthChecker { 49 49 + start_time: Instant, 50 50 + system_start_time: SystemTime, 51 51 + request_count: std::sync::atomic::AtomicU64, 52 52 + error_count: std::sync::atomic::AtomicU64, 53 53 + total_response_time: std::sync::atomic::AtomicU64, 54 54 + } 55 55 + 56 56 + impl HealthChecker { 57 57 + pub fn new() -> Self { 58 58 + Self { 59 59 + start_time: Instant::now(), 60 60 + system_start_time: SystemTime::now(), 61 61 + request_count: std::sync::atomic::AtomicU64::new(0), 62 62 + error_count: std::sync::atomic::AtomicU64::new(0), 63 63 + total_response_time: std::sync::atomic::AtomicU64::new(0), 64 64 + } 65 65 + } 66 66 + 67 67 + /// Generate a comprehensive health report 68 68 + pub fn generate_health_report(&self) -> HealthReport { 69 69 + let timestamp = SystemTime::now() 70 70 + .duration_since(UNIX_EPOCH) 71 71 + .unwrap_or_default() 72 72 + .as_secs(); 73 73 + 74 74 + let uptime = self.start_time.elapsed(); 75 75 + let mut checks = HashMap::new(); 76 76 + 77 77 + // Run all health checks 78 78 + checks.insert("memory".to_string(), self.check_memory()); 79 79 + checks.insert("disk".to_string(), self.check_disk_space()); 80 80 + checks.insert("database".to_string(), self.check_database_connectivity()); 81 81 + checks.insert("performance".to_string(), self.check_performance()); 82 82 + checks.insert("dependencies".to_string(), self.check_dependencies()); 83 83 + 84 84 + let system_info = self.get_system_info(); 85 85 + let performance_metrics = self.get_performance_metrics(); 86 86 + 87 87 + // Determine overall status 88 88 + let overall_status = self.determine_overall_status(&checks); 89 89 + 90 90 + HealthReport { 91 91 + status: overall_status, 92 92 + timestamp, 93 93 + uptime_seconds: uptime.as_secs(), 94 94 + checks, 95 95 + system_info, 96 96 + performance_metrics, 97 97 + } 98 98 + } 99 99 + 100 100 + /// Check memory usage and availability 101 101 + fn check_memory(&self) -> CheckResult { 102 102 + let start = Instant::now(); 103 103 + 104 104 + // Get system memory information (simplified) 105 105 + let memory_usage = self.get_memory_usage(); 106 106 + let mut details = HashMap::new(); 107 107 + 108 108 + let (status, message) = if memory_usage < 80.0 { 109 109 + ("healthy".to_string(), "Memory usage is within normal limits".to_string()) 110 110 + } else if memory_usage < 95.0 { 111 111 + ("warning".to_string(), "Memory usage is high".to_string()) 112 112 + } else { 113 113 + ("critical".to_string(), "Memory usage is critically high".to_string()) 114 114 + }; 115 115 + 116 116 + details.insert("usage_percent".to_string(), serde_json::Value::Number( 117 117 + serde_json::Number::from_f64(memory_usage).unwrap_or_else(|| serde_json::Number::from(0)) 118 118 + )); 119 119 + 120 120 + CheckResult { 121 121 + status, 122 122 + message, 123 123 + last_check: SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(), 124 124 + duration_ms: start.elapsed().as_millis() as u64, 125 125 + details: Some(details), 126 126 + } 127 127 + } 128 128 + 129 129 + /// Check disk space availability 130 130 + fn check_disk_space(&self) -> CheckResult { 131 131 + let start = Instant::now(); 132 132 + 133 133 + // Get disk space information (simplified) 134 134 + let disk_usage = self.get_disk_usage(); 135 135 + let mut details = HashMap::new(); 136 136 + 137 137 + let (status, message) = if disk_usage < 80.0 { 138 138 + ("healthy".to_string(), "Disk space is sufficient".to_string()) 139 139 + } else if disk_usage < 95.0 { 140 140 + ("warning".to_string(), "Disk space is running low".to_string()) 141 141 + } else { 142 142 + ("critical".to_string(), "Disk space is critically low".to_string()) 143 143 + }; 144 144 + 145 145 + details.insert("usage_percent".to_string(), serde_json::Value::Number( 146 146 + serde_json::Number::from_f64(disk_usage).unwrap_or_else(|| serde_json::Number::from(0)) 147 147 + )); 148 148 + 149 149 + CheckResult { 150 150 + status, 151 151 + message, 152 152 + last_check: SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(), 153 153 + duration_ms: start.elapsed().as_millis() as u64, 154 154 + details: Some(details), 155 155 + } 156 156 + } 157 157 + 158 158 + /// Check database connectivity and responsiveness 159 159 + fn check_database_connectivity(&self) -> CheckResult { 160 160 + let start = Instant::now(); 161 161 + 162 162 + // Simulate database connectivity check 163 163 + let is_connected = self.test_database_connection(); 164 164 + let mut details = HashMap::new(); 165 165 + 166 166 + let (status, message) = if is_connected { 167 167 + ("healthy".to_string(), "Database is accessible and responsive".to_string()) 168 168 + } else { 169 169 + ("critical".to_string(), "Database is not accessible".to_string()) 170 170 + }; 171 171 + 172 172 + details.insert("connected".to_string(), serde_json::Value::Bool(is_connected)); 173 173 + details.insert("response_time_ms".to_string(), serde_json::Value::Number( 174 174 + serde_json::Number::from(start.elapsed().as_millis() as u64) 175 175 + )); 176 176 + 177 177 + CheckResult { 178 178 + status, 179 179 + message, 180 180 + last_check: SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(), 181 181 + duration_ms: start.elapsed().as_millis() as u64, 182 182 + details: Some(details), 183 183 + } 184 184 + } 185 185 + 186 186 + /// Check overall system performance 187 187 + fn check_performance(&self) -> CheckResult { 188 188 + let start = Instant::now(); 189 189 + 190 190 + let performance_metrics = self.get_performance_metrics(); 191 191 + let mut details = HashMap::new(); 192 192 + 193 193 + let (status, message) = if performance_metrics.error_rate_percent < 1.0 { 194 194 + ("healthy".to_string(), "System performance is optimal".to_string()) 195 195 + } else if performance_metrics.error_rate_percent < 5.0 { 196 196 + ("warning".to_string(), "System performance shows some degradation".to_string()) 197 197 + } else { 198 198 + ("critical".to_string(), "System performance is severely degraded".to_string()) 199 199 + }; 200 200 + 201 201 + details.insert("error_rate_percent".to_string(), serde_json::Value::Number( 202 202 + serde_json::Number::from_f64(performance_metrics.error_rate_percent).unwrap_or_else(|| serde_json::Number::from(0)) 203 203 + )); 204 204 + details.insert("requests_per_second".to_string(), serde_json::Value::Number( 205 205 + serde_json::Number::from_f64(performance_metrics.requests_per_second).unwrap_or_else(|| serde_json::Number::from(0)) 206 206 + )); 207 207 + details.insert("average_response_time_ms".to_string(), serde_json::Value::Number( 208 208 + serde_json::Number::from_f64(performance_metrics.average_response_time_ms).unwrap_or_else(|| serde_json::Number::from(0)) 209 209 + )); 210 210 + 211 211 + CheckResult { 212 212 + status, 213 213 + message, 214 214 + last_check: SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(), 215 215 + duration_ms: start.elapsed().as_millis() as u64, 216 216 + details: Some(details), 217 217 + } 218 218 + } 219 219 + 220 220 + /// Check external dependencies and services 221 221 + fn check_dependencies(&self) -> CheckResult { 222 222 + let start = Instant::now(); 223 223 + 224 224 + // Check various dependencies 225 225 + let mut dependency_status = HashMap::new(); 226 226 + dependency_status.insert("tracing_system", true); 227 227 + dependency_status.insert("metrics_collector", true); 228 228 + dependency_status.insert("storage_backend", true); 229 229 + 230 230 + let all_healthy = dependency_status.values().all(|&status| status); 231 231 + let mut details = HashMap::new(); 232 232 + 233 233 + for (service, status) in dependency_status { 234 234 + details.insert(service.to_string(), serde_json::Value::Bool(status)); 235 235 + } 236 236 + 237 237 + let (status, message) = if all_healthy { 238 238 + ("healthy".to_string(), "All dependencies are functioning correctly".to_string()) 239 239 + } else { 240 240 + ("warning".to_string(), "Some dependencies are experiencing issues".to_string()) 241 241 + }; 242 242 + 243 243 + CheckResult { 244 244 + status, 245 245 + message, 246 246 + last_check: SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(), 247 247 + duration_ms: start.elapsed().as_millis() as u64, 248 248 + details: Some(details), 249 249 + } 250 250 + } 251 251 + 252 252 + /// Get system information 253 253 + fn get_system_info(&self) -> SystemInfo { 254 254 + SystemInfo { 255 255 + version: env!("CARGO_PKG_VERSION").to_string(), 256 256 + build_time: option_env!("VERGEN_BUILD_TIMESTAMP").unwrap_or("unknown").to_string(), 257 257 + rust_version: option_env!("VERGEN_RUSTC_SEMVER").unwrap_or("unknown").to_string(), 258 258 + target_architecture: std::env::consts::ARCH.to_string(), 259 259 + memory_usage_mb: self.get_memory_usage_mb(), 260 260 + cpu_count: num_cpus::get(), 261 261 + } 262 262 + } 263 263 + 264 264 + /// Get performance metrics 265 265 + fn get_performance_metrics(&self) -> PerformanceMetrics { 266 266 + let uptime_secs = self.start_time.elapsed().as_secs_f64(); 267 267 + let total_requests = self.request_count.load(std::sync::atomic::Ordering::Relaxed); 268 268 + let total_errors = self.error_count.load(std::sync::atomic::Ordering::Relaxed); 269 269 + let total_response_time = self.total_response_time.load(std::sync::atomic::Ordering::Relaxed); 270 270 + 271 271 + let requests_per_second = if uptime_secs > 0.0 { 272 272 + total_requests as f64 / uptime_secs 273 273 + } else { 274 274 + 0.0 275 275 + }; 276 276 + 277 277 + let average_response_time_ms = if total_requests > 0 { 278 278 + (total_response_time as f64 / total_requests as f64) / 1_000_000.0 // Convert from nanoseconds to milliseconds 279 279 + } else { 280 280 + 0.0 281 281 + }; 282 282 + 283 283 + let error_rate_percent = if total_requests > 0 { 284 284 + (total_errors as f64 / total_requests as f64) * 100.0 285 285 + } else { 286 286 + 0.0 287 287 + }; 288 288 + 289 289 + PerformanceMetrics { 290 290 + total_requests, 291 291 + requests_per_second, 292 292 + average_response_time_ms, 293 293 + error_rate_percent, 294 294 + memory_usage_percent: self.get_memory_usage(), 295 295 + disk_usage_percent: self.get_disk_usage(), 296 296 + } 297 297 + } 298 298 + 299 299 + /// Record a request for performance tracking 300 300 + pub fn record_request(&self, response_time: Duration, is_error: bool) { 301 301 + self.request_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed); 302 302 + self.total_response_time.fetch_add( 303 303 + response_time.as_nanos() as u64, 304 304 + std::sync::atomic::Ordering::Relaxed 305 305 + ); 306 306 + 307 307 + if is_error { 308 308 + self.error_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed); 309 309 + } 310 310 + } 311 311 + 312 312 + /// Determine overall system status based on individual checks 313 313 + fn determine_overall_status(&self, checks: &HashMap<String, CheckResult>) -> String { 314 314 + let has_critical = checks.values().any(|check| check.status == "critical"); 315 315 + let has_warning = checks.values().any(|check| check.status == "warning"); 316 316 + 317 317 + if has_critical { 318 318 + "critical".to_string() 319 319 + } else if has_warning { 320 320 + "warning".to_string() 321 321 + } else { 322 322 + "healthy".to_string() 323 323 + } 324 324 + } 325 325 + 326 326 + // Helper methods (simplified implementations) 327 327 + 328 328 + fn get_memory_usage(&self) -> f64 { 329 329 + // Simplified memory usage calculation 330 330 + // In a real implementation, you would use system APIs 331 331 + 50.0 // Return a placeholder value 332 332 + } 333 333 + 334 334 + fn get_memory_usage_mb(&self) -> f64 { 335 335 + // Simplified memory usage in MB 336 336 + 512.0 // Return a placeholder value 337 337 + } 338 338 + 339 339 + fn get_disk_usage(&self) -> f64 { 340 340 + // Simplified disk usage calculation 341 341 + // In a real implementation, you would check actual disk usage 342 342 + 30.0 // Return a placeholder value 343 343 + } 344 344 + 345 345 + fn test_database_connection(&self) -> bool { 346 346 + // Simplified database connectivity test 347 347 + // In a real implementation, you would test actual database connectivity 348 348 + true // Return a placeholder value 349 349 + } 350 350 + } 351 351 + 352 352 + impl Default for HealthChecker { 353 353 + fn default() -> Self { 354 354 + Self::new() 355 355 + } 356 356 + } 357 357 + 358 358 + /// Convert HealthLevel to string for JSON serialization 359 359 + impl HealthLevel { 360 360 + pub fn as_str(&self) -> &'static str { 361 361 + match self { 362 362 + HealthLevel::Healthy => "healthy", 363 363 + HealthLevel::Warning => "warning", 364 364 + HealthLevel::Critical => "critical", 365 365 + HealthLevel::Unknown => "unknown", 366 366 + } 367 367 + } 368 368 + } 369 369 + 370 370 + impl From<&str> for HealthLevel { 371 371 + fn from(s: &str) -> Self { 372 372 + match s.to_lowercase().as_str() { 373 373 + "healthy" => HealthLevel::Healthy, 374 374 + "warning" => HealthLevel::Warning, 375 375 + "critical" => HealthLevel::Critical, 376 376 + _ => HealthLevel::Unknown, 377 377 + } 378 378 + } 379 379 + } 380 380 + 381 381 + #[cfg(test)] 382 382 + mod tests { 383 383 + use super::*; 384 384 + 385 385 + #[test] 386 386 + fn test_health_checker_creation() { 387 387 + let checker = HealthChecker::new(); 388 388 + assert!(checker.start_time.elapsed() < Duration::from_secs(1)); 389 389 + } 390 390 + 391 391 + #[test] 392 392 + fn test_health_report_generation() { 393 393 + let checker = HealthChecker::new(); 394 394 + let report = checker.generate_health_report(); 395 395 + 396 396 + assert!(!report.status.is_empty()); 397 397 + assert!(report.uptime_seconds < 60); // Should be very recent 398 398 + assert!(!report.checks.is_empty()); 399 399 + assert_eq!(report.system_info.version, env!("CARGO_PKG_VERSION")); 400 400 + } 401 401 + 402 402 + #[test] 403 403 + fn test_request_recording() { 404 404 + let checker = HealthChecker::new(); 405 405 + 406 406 + checker.record_request(Duration::from_millis(100), false); 407 407 + checker.record_request(Duration::from_millis(200), true); 408 408 + 409 409 + let metrics = checker.get_performance_metrics(); 410 410 + assert_eq!(metrics.total_requests, 2); 411 411 + assert_eq!(metrics.error_rate_percent, 50.0); 412 412 + } 413 413 + 414 414 + #[test] 415 415 + fn test_health_level_conversion() { 416 416 + assert_eq!(HealthLevel::Healthy.as_str(), "healthy"); 417 417 + assert_eq!(HealthLevel::Warning.as_str(), "warning"); 418 418 + assert_eq!(HealthLevel::Critical.as_str(), "critical"); 419 419 + assert_eq!(HealthLevel::Unknown.as_str(), "unknown"); 420 420 + 421 421 + assert_eq!(HealthLevel::from("healthy"), HealthLevel::Healthy); 422 422 + assert_eq!(HealthLevel::from("warning"), HealthLevel::Warning); 423 423 + assert_eq!(HealthLevel::from("critical"), HealthLevel::Critical); 424 424 + assert_eq!(HealthLevel::from("unknown"), HealthLevel::Unknown); 425 425 + } 426 426 + }

+515

src/observability/metrics.rs

reviewed

··· 1 1 + use prometheus::{ 2 2 + Registry, Counter, Histogram, Gauge, Opts, HistogramOpts, 3 3 + register_counter_with_registry, register_histogram_with_registry, register_gauge_with_registry, 4 4 + }; 5 5 + // use metrics::{describe_counter, describe_histogram, describe_gauge, counter, histogram, gauge}; 6 6 + use std::sync::Arc; 7 7 + use std::time::Duration; 8 8 + use tracing::{info, debug, error}; 9 9 + use crate::{Result as GigabrainResult, GigabrainError}; 10 10 + 11 11 + /// Metrics registration and management system 12 12 + pub struct MetricsRegistry { 13 13 + registry: Registry, 14 14 + 15 15 + // Application-specific metrics 16 16 + pub graph_operations: GraphOperationMetrics, 17 17 + pub api_metrics: ApiMetrics, 18 18 + pub system_metrics: SystemMetrics, 19 19 + pub performance_metrics: PerformanceMetrics, 20 20 + } 21 21 + 22 22 + /// Graph operation metrics 23 23 + pub struct GraphOperationMetrics { 24 24 + pub nodes_created_total: Counter, 25 25 + pub nodes_deleted_total: Counter, 26 26 + pub nodes_updated_total: Counter, 27 27 + pub nodes_queried_total: Counter, 28 28 + 29 29 + pub relationships_created_total: Counter, 30 30 + pub relationships_deleted_total: Counter, 31 31 + pub relationships_queried_total: Counter, 32 32 + 33 33 + pub operation_duration: Histogram, 34 34 + pub operation_errors_total: Counter, 35 35 + 36 36 + pub constraint_validations_total: Counter, 37 37 + pub constraint_violations_total: Counter, 38 38 + } 39 39 + 40 40 + /// API-specific metrics 41 41 + pub struct ApiMetrics { 42 42 + pub http_requests_total: Counter, 43 43 + pub http_request_duration: Histogram, 44 44 + pub http_response_size: Histogram, 45 45 + pub http_errors_total: Counter, 46 46 + 47 47 + pub grpc_requests_total: Counter, 48 48 + pub grpc_request_duration: Histogram, 49 49 + pub grpc_errors_total: Counter, 50 50 + 51 51 + pub concurrent_connections: Gauge, 52 52 + pub request_queue_size: Gauge, 53 53 + } 54 54 + 55 55 + /// System resource metrics 56 56 + pub struct SystemMetrics { 57 57 + pub memory_usage_bytes: Gauge, 58 58 + pub memory_usage_percent: Gauge, 59 59 + pub cpu_usage_percent: Gauge, 60 60 + pub disk_usage_bytes: Gauge, 61 61 + pub disk_usage_percent: Gauge, 62 62 + 63 63 + pub open_file_descriptors: Gauge, 64 64 + pub thread_count: Gauge, 65 65 + pub heap_size_bytes: Gauge, 66 66 + 67 67 + pub gc_collections_total: Counter, 68 68 + pub gc_duration_total: Counter, 69 69 + } 70 70 + 71 71 + /// Performance and latency metrics 72 72 + pub struct PerformanceMetrics { 73 73 + pub throughput_ops_per_second: Gauge, 74 74 + pub latency_percentiles: LatencyPercentiles, 75 75 + 76 76 + pub cache_hits_total: Counter, 77 77 + pub cache_misses_total: Counter, 78 78 + pub cache_hit_ratio: Gauge, 79 79 + 80 80 + pub index_lookups_total: Counter, 81 81 + pub index_lookup_duration: Histogram, 82 82 + 83 83 + pub background_tasks_total: Counter, 84 84 + pub background_task_duration: Histogram, 85 85 + } 86 86 + 87 87 + /// Latency percentile metrics 88 88 + pub struct LatencyPercentiles { 89 89 + pub p50: Gauge, 90 90 + pub p90: Gauge, 91 91 + pub p95: Gauge, 92 92 + pub p99: Gauge, 93 93 + pub p999: Gauge, 94 94 + } 95 95 + 96 96 + impl MetricsRegistry { 97 97 + pub fn new() -> GigabrainResult<Self> { 98 98 + let registry = Registry::new(); 99 99 + 100 100 + let graph_operations = GraphOperationMetrics::new(&registry)?; 101 101 + let api_metrics = ApiMetrics::new(&registry)?; 102 102 + let system_metrics = SystemMetrics::new(&registry)?; 103 103 + let performance_metrics = PerformanceMetrics::new(&registry)?; 104 104 + 105 105 + Ok(Self { 106 106 + registry, 107 107 + graph_operations, 108 108 + api_metrics, 109 109 + system_metrics, 110 110 + performance_metrics, 111 111 + }) 112 112 + } 113 113 + 114 114 + pub fn get_registry(&self) -> &Registry { 115 115 + &self.registry 116 116 + } 117 117 + 118 118 + /// Initialize global metrics descriptions for the metrics crate 119 119 + pub fn init_global_metrics() { 120 120 + info!("Global metrics descriptions initialized (simplified for compatibility)"); 121 121 + } 122 122 + 123 123 + /// Record metrics using Prometheus only 124 124 + pub fn record_node_created(&self) { 125 125 + self.graph_operations.nodes_created_total.inc(); 126 126 + } 127 127 + 128 128 + pub fn record_node_deleted(&self) { 129 129 + self.graph_operations.nodes_deleted_total.inc(); 130 130 + } 131 131 + 132 132 + pub fn record_node_updated(&self) { 133 133 + self.graph_operations.nodes_updated_total.inc(); 134 134 + } 135 135 + 136 136 + pub fn record_node_queried(&self) { 137 137 + self.graph_operations.nodes_queried_total.inc(); 138 138 + } 139 139 + 140 140 + pub fn record_relationship_created(&self) { 141 141 + self.graph_operations.relationships_created_total.inc(); 142 142 + } 143 143 + 144 144 + pub fn record_relationship_deleted(&self) { 145 145 + self.graph_operations.relationships_deleted_total.inc(); 146 146 + } 147 147 + 148 148 + pub fn record_relationship_queried(&self) { 149 149 + self.graph_operations.relationships_queried_total.inc(); 150 150 + } 151 151 + 152 152 + pub fn record_operation_duration(&self, duration: Duration) { 153 153 + let seconds = duration.as_secs_f64(); 154 154 + self.graph_operations.operation_duration.observe(seconds); 155 155 + } 156 156 + 157 157 + pub fn record_operation_error(&self) { 158 158 + self.graph_operations.operation_errors_total.inc(); 159 159 + } 160 160 + 161 161 + pub fn record_http_request(&self, duration: Duration, response_size: usize) { 162 162 + self.api_metrics.http_requests_total.inc(); 163 163 + self.api_metrics.http_request_duration.observe(duration.as_secs_f64()); 164 164 + self.api_metrics.http_response_size.observe(response_size as f64); 165 165 + } 166 166 + 167 167 + pub fn record_http_error(&self) { 168 168 + self.api_metrics.http_errors_total.inc(); 169 169 + } 170 170 + 171 171 + pub fn update_concurrent_connections(&self, count: i64) { 172 172 + self.api_metrics.concurrent_connections.add(count as f64); 173 173 + } 174 174 + 175 175 + pub fn update_memory_usage(&self, bytes: u64, percent: f64) { 176 176 + self.system_metrics.memory_usage_bytes.set(bytes as f64); 177 177 + self.system_metrics.memory_usage_percent.set(percent); 178 178 + } 179 179 + 180 180 + pub fn update_cpu_usage(&self, percent: f64) { 181 181 + self.system_metrics.cpu_usage_percent.set(percent); 182 182 + } 183 183 + 184 184 + pub fn update_throughput(&self, ops_per_second: f64) { 185 185 + self.performance_metrics.throughput_ops_per_second.set(ops_per_second); 186 186 + } 187 187 + 188 188 + pub fn update_latency_percentiles(&self, p50: f64, p90: f64, p95: f64, p99: f64, p999: f64) { 189 189 + self.performance_metrics.latency_percentiles.p50.set(p50); 190 190 + self.performance_metrics.latency_percentiles.p90.set(p90); 191 191 + self.performance_metrics.latency_percentiles.p95.set(p95); 192 192 + self.performance_metrics.latency_percentiles.p99.set(p99); 193 193 + self.performance_metrics.latency_percentiles.p999.set(p999); 194 194 + } 195 195 + 196 196 + pub fn record_cache_hit(&self) { 197 197 + self.performance_metrics.cache_hits_total.inc(); 198 198 + } 199 199 + 200 200 + pub fn record_cache_miss(&self) { 201 201 + self.performance_metrics.cache_misses_total.inc(); 202 202 + } 203 203 + 204 204 + pub fn update_cache_hit_ratio(&self, ratio: f64) { 205 205 + self.performance_metrics.cache_hit_ratio.set(ratio); 206 206 + } 207 207 + } 208 208 + 209 209 + impl GraphOperationMetrics { 210 210 + fn new(registry: &Registry) -> GigabrainResult<Self> { 211 211 + let nodes_created_total = register_counter_with_registry!( 212 212 + Opts::new("gigabrain_nodes_created_total", "Total number of nodes created"), 213 213 + registry 214 214 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register nodes_created_total: {}", e)))?; 215 215 + 216 216 + let nodes_deleted_total = register_counter_with_registry!( 217 217 + Opts::new("gigabrain_nodes_deleted_total", "Total number of nodes deleted"), 218 218 + registry 219 219 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register nodes_deleted_total: {}", e)))?; 220 220 + 221 221 + let nodes_updated_total = register_counter_with_registry!( 222 222 + Opts::new("gigabrain_nodes_updated_total", "Total number of nodes updated"), 223 223 + registry 224 224 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register nodes_updated_total: {}", e)))?; 225 225 + 226 226 + let nodes_queried_total = register_counter_with_registry!( 227 227 + Opts::new("gigabrain_nodes_queried_total", "Total number of node queries"), 228 228 + registry 229 229 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register nodes_queried_total: {}", e)))?; 230 230 + 231 231 + let relationships_created_total = register_counter_with_registry!( 232 232 + Opts::new("gigabrain_relationships_created_total", "Total number of relationships created"), 233 233 + registry 234 234 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register relationships_created_total: {}", e)))?; 235 235 + 236 236 + let relationships_deleted_total = register_counter_with_registry!( 237 237 + Opts::new("gigabrain_relationships_deleted_total", "Total number of relationships deleted"), 238 238 + registry 239 239 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register relationships_deleted_total: {}", e)))?; 240 240 + 241 241 + let relationships_queried_total = register_counter_with_registry!( 242 242 + Opts::new("gigabrain_relationships_queried_total", "Total number of relationship queries"), 243 243 + registry 244 244 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register relationships_queried_total: {}", e)))?; 245 245 + 246 246 + let operation_duration = register_histogram_with_registry!( 247 247 + HistogramOpts::new("gigabrain_operation_duration_seconds", "Duration of graph operations") 248 248 + .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]), 249 249 + registry 250 250 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register operation_duration: {}", e)))?; 251 251 + 252 252 + let operation_errors_total = register_counter_with_registry!( 253 253 + Opts::new("gigabrain_operation_errors_total", "Total number of operation errors"), 254 254 + registry 255 255 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register operation_errors_total: {}", e)))?; 256 256 + 257 257 + let constraint_validations_total = register_counter_with_registry!( 258 258 + Opts::new("gigabrain_constraint_validations_total", "Total number of constraint validations"), 259 259 + registry 260 260 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register constraint_validations_total: {}", e)))?; 261 261 + 262 262 + let constraint_violations_total = register_counter_with_registry!( 263 263 + Opts::new("gigabrain_constraint_violations_total", "Total number of constraint violations"), 264 264 + registry 265 265 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register constraint_violations_total: {}", e)))?; 266 266 + 267 267 + Ok(Self { 268 268 + nodes_created_total, 269 269 + nodes_deleted_total, 270 270 + nodes_updated_total, 271 271 + nodes_queried_total, 272 272 + relationships_created_total, 273 273 + relationships_deleted_total, 274 274 + relationships_queried_total, 275 275 + operation_duration, 276 276 + operation_errors_total, 277 277 + constraint_validations_total, 278 278 + constraint_violations_total, 279 279 + }) 280 280 + } 281 281 + } 282 282 + 283 283 + impl ApiMetrics { 284 284 + fn new(registry: &Registry) -> GigabrainResult<Self> { 285 285 + let http_requests_total = register_counter_with_registry!( 286 286 + Opts::new("gigabrain_http_requests_total", "Total number of HTTP requests"), 287 287 + registry 288 288 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register http_requests_total: {}", e)))?; 289 289 + 290 290 + let http_request_duration = register_histogram_with_registry!( 291 291 + HistogramOpts::new("gigabrain_http_request_duration_seconds", "Duration of HTTP requests") 292 292 + .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]), 293 293 + registry 294 294 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register http_request_duration: {}", e)))?; 295 295 + 296 296 + let http_response_size = register_histogram_with_registry!( 297 297 + HistogramOpts::new("gigabrain_http_response_size_bytes", "Size of HTTP responses") 298 298 + .buckets(vec![100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0]), 299 299 + registry 300 300 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register http_response_size: {}", e)))?; 301 301 + 302 302 + let http_errors_total = register_counter_with_registry!( 303 303 + Opts::new("gigabrain_http_errors_total", "Total number of HTTP errors"), 304 304 + registry 305 305 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register http_errors_total: {}", e)))?; 306 306 + 307 307 + let grpc_requests_total = register_counter_with_registry!( 308 308 + Opts::new("gigabrain_grpc_requests_total", "Total number of gRPC requests"), 309 309 + registry 310 310 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register grpc_requests_total: {}", e)))?; 311 311 + 312 312 + let grpc_request_duration = register_histogram_with_registry!( 313 313 + HistogramOpts::new("gigabrain_grpc_request_duration_seconds", "Duration of gRPC requests") 314 314 + .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]), 315 315 + registry 316 316 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register grpc_request_duration: {}", e)))?; 317 317 + 318 318 + let grpc_errors_total = register_counter_with_registry!( 319 319 + Opts::new("gigabrain_grpc_errors_total", "Total number of gRPC errors"), 320 320 + registry 321 321 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register grpc_errors_total: {}", e)))?; 322 322 + 323 323 + let concurrent_connections = register_gauge_with_registry!( 324 324 + Opts::new("gigabrain_concurrent_connections", "Number of concurrent connections"), 325 325 + registry 326 326 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register concurrent_connections: {}", e)))?; 327 327 + 328 328 + let request_queue_size = register_gauge_with_registry!( 329 329 + Opts::new("gigabrain_request_queue_size", "Size of the request queue"), 330 330 + registry 331 331 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register request_queue_size: {}", e)))?; 332 332 + 333 333 + Ok(Self { 334 334 + http_requests_total, 335 335 + http_request_duration, 336 336 + http_response_size, 337 337 + http_errors_total, 338 338 + grpc_requests_total, 339 339 + grpc_request_duration, 340 340 + grpc_errors_total, 341 341 + concurrent_connections, 342 342 + request_queue_size, 343 343 + }) 344 344 + } 345 345 + } 346 346 + 347 347 + impl SystemMetrics { 348 348 + fn new(registry: &Registry) -> GigabrainResult<Self> { 349 349 + let memory_usage_bytes = register_gauge_with_registry!( 350 350 + Opts::new("gigabrain_memory_usage_bytes", "Memory usage in bytes"), 351 351 + registry 352 352 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register memory_usage_bytes: {}", e)))?; 353 353 + 354 354 + let memory_usage_percent = register_gauge_with_registry!( 355 355 + Opts::new("gigabrain_memory_usage_percent", "Memory usage percentage"), 356 356 + registry 357 357 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register memory_usage_percent: {}", e)))?; 358 358 + 359 359 + let cpu_usage_percent = register_gauge_with_registry!( 360 360 + Opts::new("gigabrain_cpu_usage_percent", "CPU usage percentage"), 361 361 + registry 362 362 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register cpu_usage_percent: {}", e)))?; 363 363 + 364 364 + let disk_usage_bytes = register_gauge_with_registry!( 365 365 + Opts::new("gigabrain_disk_usage_bytes", "Disk usage in bytes"), 366 366 + registry 367 367 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register disk_usage_bytes: {}", e)))?; 368 368 + 369 369 + let disk_usage_percent = register_gauge_with_registry!( 370 370 + Opts::new("gigabrain_disk_usage_percent", "Disk usage percentage"), 371 371 + registry 372 372 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register disk_usage_percent: {}", e)))?; 373 373 + 374 374 + let open_file_descriptors = register_gauge_with_registry!( 375 375 + Opts::new("gigabrain_open_file_descriptors", "Number of open file descriptors"), 376 376 + registry 377 377 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register open_file_descriptors: {}", e)))?; 378 378 + 379 379 + let thread_count = register_gauge_with_registry!( 380 380 + Opts::new("gigabrain_thread_count", "Number of threads"), 381 381 + registry 382 382 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register thread_count: {}", e)))?; 383 383 + 384 384 + let heap_size_bytes = register_gauge_with_registry!( 385 385 + Opts::new("gigabrain_heap_size_bytes", "Heap size in bytes"), 386 386 + registry 387 387 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register heap_size_bytes: {}", e)))?; 388 388 + 389 389 + let gc_collections_total = register_counter_with_registry!( 390 390 + Opts::new("gigabrain_gc_collections_total", "Total number of garbage collections"), 391 391 + registry 392 392 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register gc_collections_total: {}", e)))?; 393 393 + 394 394 + let gc_duration_total = register_counter_with_registry!( 395 395 + Opts::new("gigabrain_gc_duration_total", "Total time spent in garbage collection"), 396 396 + registry 397 397 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register gc_duration_total: {}", e)))?; 398 398 + 399 399 + Ok(Self { 400 400 + memory_usage_bytes, 401 401 + memory_usage_percent, 402 402 + cpu_usage_percent, 403 403 + disk_usage_bytes, 404 404 + disk_usage_percent, 405 405 + open_file_descriptors, 406 406 + thread_count, 407 407 + heap_size_bytes, 408 408 + gc_collections_total, 409 409 + gc_duration_total, 410 410 + }) 411 411 + } 412 412 + } 413 413 + 414 414 + impl PerformanceMetrics { 415 415 + fn new(registry: &Registry) -> GigabrainResult<Self> { 416 416 + let throughput_ops_per_second = register_gauge_with_registry!( 417 417 + Opts::new("gigabrain_throughput_ops_per_second", "Operations per second"), 418 418 + registry 419 419 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register throughput_ops_per_second: {}", e)))?; 420 420 + 421 421 + let latency_percentiles = LatencyPercentiles::new(registry)?; 422 422 + 423 423 + let cache_hits_total = register_counter_with_registry!( 424 424 + Opts::new("gigabrain_cache_hits_total", "Total number of cache hits"), 425 425 + registry 426 426 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register cache_hits_total: {}", e)))?; 427 427 + 428 428 + let cache_misses_total = register_counter_with_registry!( 429 429 + Opts::new("gigabrain_cache_misses_total", "Total number of cache misses"), 430 430 + registry 431 431 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register cache_misses_total: {}", e)))?; 432 432 + 433 433 + let cache_hit_ratio = register_gauge_with_registry!( 434 434 + Opts::new("gigabrain_cache_hit_ratio", "Cache hit ratio"), 435 435 + registry 436 436 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register cache_hit_ratio: {}", e)))?; 437 437 + 438 438 + let index_lookups_total = register_counter_with_registry!( 439 439 + Opts::new("gigabrain_index_lookups_total", "Total number of index lookups"), 440 440 + registry 441 441 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register index_lookups_total: {}", e)))?; 442 442 + 443 443 + let index_lookup_duration = register_histogram_with_registry!( 444 444 + HistogramOpts::new("gigabrain_index_lookup_duration_seconds", "Duration of index lookups") 445 445 + .buckets(vec![0.0001, 0.0005, 0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5]), 446 446 + registry 447 447 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register index_lookup_duration: {}", e)))?; 448 448 + 449 449 + let background_tasks_total = register_counter_with_registry!( 450 450 + Opts::new("gigabrain_background_tasks_total", "Total number of background tasks"), 451 451 + registry 452 452 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register background_tasks_total: {}", e)))?; 453 453 + 454 454 + let background_task_duration = register_histogram_with_registry!( 455 455 + HistogramOpts::new("gigabrain_background_task_duration_seconds", "Duration of background tasks") 456 456 + .buckets(vec![0.1, 0.5, 1.0, 5.0, 10.0, 30.0, 60.0, 300.0, 600.0]), 457 457 + registry 458 458 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register background_task_duration: {}", e)))?; 459 459 + 460 460 + Ok(Self { 461 461 + throughput_ops_per_second, 462 462 + latency_percentiles, 463 463 + cache_hits_total, 464 464 + cache_misses_total, 465 465 + cache_hit_ratio, 466 466 + index_lookups_total, 467 467 + index_lookup_duration, 468 468 + background_tasks_total, 469 469 + background_task_duration, 470 470 + }) 471 471 + } 472 472 + } 473 473 + 474 474 + impl LatencyPercentiles { 475 475 + fn new(registry: &Registry) -> GigabrainResult<Self> { 476 476 + let p50 = register_gauge_with_registry!( 477 477 + Opts::new("gigabrain_latency_p50_seconds", "50th percentile latency"), 478 478 + registry 479 479 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register latency_p50: {}", e)))?; 480 480 + 481 481 + let p90 = register_gauge_with_registry!( 482 482 + Opts::new("gigabrain_latency_p90_seconds", "90th percentile latency"), 483 483 + registry 484 484 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register latency_p90: {}", e)))?; 485 485 + 486 486 + let p95 = register_gauge_with_registry!( 487 487 + Opts::new("gigabrain_latency_p95_seconds", "95th percentile latency"), 488 488 + registry 489 489 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register latency_p95: {}", e)))?; 490 490 + 491 491 + let p99 = register_gauge_with_registry!( 492 492 + Opts::new("gigabrain_latency_p99_seconds", "99th percentile latency"), 493 493 + registry 494 494 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register latency_p99: {}", e)))?; 495 495 + 496 496 + let p999 = register_gauge_with_registry!( 497 497 + Opts::new("gigabrain_latency_p999_seconds", "99.9th percentile latency"), 498 498 + registry 499 499 + ).map_err(|e| GigabrainError::Storage(format!("Failed to register latency_p999: {}", e)))?; 500 500 + 501 501 + Ok(Self { 502 502 + p50, 503 503 + p90, 504 504 + p95, 505 505 + p99, 506 506 + p999, 507 507 + }) 508 508 + } 509 509 + } 510 510 + 511 511 + impl Default for MetricsRegistry { 512 512 + fn default() -> Self { 513 513 + Self::new().expect("Failed to create metrics registry") 514 514 + } 515 515 + }

+637

src/observability/mod.rs

reviewed

··· 1 1 + use std::sync::Arc; 2 2 + use std::time::{Duration, Instant}; 3 3 + use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering}; 4 4 + use parking_lot::RwLock; 5 5 + use std::collections::HashMap; 6 6 + use tracing::{info, warn, error, debug, instrument, Span}; 7 7 + // use metrics::{counter, histogram, gauge, describe_counter, describe_histogram, describe_gauge}; 8 8 + use prometheus::{Registry, Counter, Histogram, Gauge, Opts, HistogramOpts}; 9 9 + 10 10 + pub mod metrics; 11 11 + pub mod tracing_setup; 12 12 + pub mod health; 13 13 + 14 14 + use crate::Result as GigabrainResult; 15 15 + use crate::GigabrainError; 16 16 + 17 17 + /// Comprehensive observability system for GigaBrain 18 18 + /// Provides metrics collection, distributed tracing, and health monitoring 19 19 + #[derive(Clone)] 20 20 + pub struct ObservabilitySystem { 21 21 + pub metrics: Arc<MetricsCollector>, 22 22 + pub health: Arc<HealthMonitor>, 23 23 + pub performance: Arc<PerformanceTracker>, 24 24 + } 25 25 + 26 26 + impl ObservabilitySystem { 27 27 + pub fn new() -> GigabrainResult<Self> { 28 28 + let metrics = Arc::new(MetricsCollector::new()?); 29 29 + let health = Arc::new(HealthMonitor::new()); 30 30 + let performance = Arc::new(PerformanceTracker::new()); 31 31 + 32 32 + Ok(Self { 33 33 + metrics, 34 34 + health, 35 35 + performance, 36 36 + }) 37 37 + } 38 38 + 39 39 + /// Initialize and start all observability components 40 40 + pub async fn start(&self) -> GigabrainResult<()> { 41 41 + info!("Starting observability system"); 42 42 + 43 43 + self.metrics.register_metrics()?; 44 44 + self.health.start_health_checks().await; 45 45 + self.performance.start_collection(); 46 46 + 47 47 + info!("Observability system started successfully"); 48 48 + Ok(()) 49 49 + } 50 50 + 51 51 + /// Get current system health status 52 52 + pub fn get_health_status(&self) -> HealthStatus { 53 53 + self.health.get_status() 54 54 + } 55 55 + 56 56 + /// Record a node operation for metrics 57 57 + #[instrument(skip(self))] 58 58 + pub fn record_node_operation(&self, operation: &str, duration: Duration, success: bool) { 59 59 + self.metrics.record_node_operation(operation, duration, success); 60 60 + self.performance.record_operation(operation, duration); 61 61 + } 62 62 + 63 63 + /// Record a relationship operation for metrics 64 64 + #[instrument(skip(self))] 65 65 + pub fn record_relationship_operation(&self, operation: &str, duration: Duration, success: bool) { 66 66 + self.metrics.record_relationship_operation(operation, duration, success); 67 67 + self.performance.record_operation(operation, duration); 68 68 + } 69 69 + 70 70 + /// Record query execution metrics 71 71 + #[instrument(skip(self))] 72 72 + pub fn record_query_execution(&self, query_type: &str, duration: Duration, result_count: usize) { 73 73 + self.metrics.record_query_execution(query_type, duration, result_count); 74 74 + self.performance.record_query(query_type, duration, result_count); 75 75 + } 76 76 + 77 77 + /// Update system resource metrics 78 78 + pub fn update_system_metrics(&self, node_count: u64, relationship_count: u64, memory_usage: u64) { 79 79 + self.metrics.update_system_metrics(node_count, relationship_count, memory_usage); 80 80 + } 81 81 + 82 82 + /// Get performance statistics 83 83 + pub fn get_performance_stats(&self) -> PerformanceStats { 84 84 + self.performance.get_stats() 85 85 + } 86 86 + } 87 87 + 88 88 + /// Metrics collection system using Prometheus 89 89 + pub struct MetricsCollector { 90 90 + registry: Registry, 91 91 + 92 92 + // Node operation metrics 93 93 + node_operations_total: Counter, 94 94 + node_operation_duration: Histogram, 95 95 + node_operation_errors: Counter, 96 96 + 97 97 + // Relationship operation metrics 98 98 + relationship_operations_total: Counter, 99 99 + relationship_operation_duration: Histogram, 100 100 + relationship_operation_errors: Counter, 101 101 + 102 102 + // Query metrics 103 103 + query_executions_total: Counter, 104 104 + query_duration: Histogram, 105 105 + query_result_count: Histogram, 106 106 + 107 107 + // System metrics 108 108 + nodes_total: Gauge, 109 109 + relationships_total: Gauge, 110 110 + memory_usage_bytes: Gauge, 111 111 + 112 112 + // API metrics 113 113 + http_requests_total: Counter, 114 114 + http_request_duration: Histogram, 115 115 + http_response_size: Histogram, 116 116 + 117 117 + // Performance metrics 118 118 + throughput_ops_per_second: Gauge, 119 119 + latency_p95: Gauge, 120 120 + latency_p99: Gauge, 121 121 + } 122 122 + 123 123 + impl MetricsCollector { 124 124 + pub fn new() -> GigabrainResult<Self> { 125 125 + let registry = Registry::new(); 126 126 + 127 127 + // Node operation metrics 128 128 + let node_operations_total = Counter::with_opts( 129 129 + Opts::new("gigabrain_node_operations_total", "Total number of node operations") 130 130 + .namespace("gigabrain") 131 131 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create node operations counter: {}", e)))?; 132 132 + 133 133 + let node_operation_duration = Histogram::with_opts( 134 134 + HistogramOpts::new("gigabrain_node_operation_duration_seconds", "Duration of node operations") 135 135 + .namespace("gigabrain") 136 136 + .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]) 137 137 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create node operation duration histogram: {}", e)))?; 138 138 + 139 139 + let node_operation_errors = Counter::with_opts( 140 140 + Opts::new("gigabrain_node_operation_errors_total", "Total number of node operation errors") 141 141 + .namespace("gigabrain") 142 142 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create node operation errors counter: {}", e)))?; 143 143 + 144 144 + // Relationship operation metrics 145 145 + let relationship_operations_total = Counter::with_opts( 146 146 + Opts::new("gigabrain_relationship_operations_total", "Total number of relationship operations") 147 147 + .namespace("gigabrain") 148 148 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create relationship operations counter: {}", e)))?; 149 149 + 150 150 + let relationship_operation_duration = Histogram::with_opts( 151 151 + HistogramOpts::new("gigabrain_relationship_operation_duration_seconds", "Duration of relationship operations") 152 152 + .namespace("gigabrain") 153 153 + .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]) 154 154 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create relationship operation duration histogram: {}", e)))?; 155 155 + 156 156 + let relationship_operation_errors = Counter::with_opts( 157 157 + Opts::new("gigabrain_relationship_operation_errors_total", "Total number of relationship operation errors") 158 158 + .namespace("gigabrain") 159 159 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create relationship operation errors counter: {}", e)))?; 160 160 + 161 161 + // Query metrics 162 162 + let query_executions_total = Counter::with_opts( 163 163 + Opts::new("gigabrain_query_executions_total", "Total number of query executions") 164 164 + .namespace("gigabrain") 165 165 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create query executions counter: {}", e)))?; 166 166 + 167 167 + let query_duration = Histogram::with_opts( 168 168 + HistogramOpts::new("gigabrain_query_duration_seconds", "Duration of query executions") 169 169 + .namespace("gigabrain") 170 170 + .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]) 171 171 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create query duration histogram: {}", e)))?; 172 172 + 173 173 + let query_result_count = Histogram::with_opts( 174 174 + HistogramOpts::new("gigabrain_query_result_count", "Number of results returned by queries") 175 175 + .namespace("gigabrain") 176 176 + .buckets(vec![1.0, 10.0, 50.0, 100.0, 500.0, 1000.0, 5000.0, 10000.0]) 177 177 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create query result count histogram: {}", e)))?; 178 178 + 179 179 + // System metrics 180 180 + let nodes_total = Gauge::with_opts( 181 181 + Opts::new("gigabrain_nodes_total", "Total number of nodes in the graph") 182 182 + .namespace("gigabrain") 183 183 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create nodes total gauge: {}", e)))?; 184 184 + 185 185 + let relationships_total = Gauge::with_opts( 186 186 + Opts::new("gigabrain_relationships_total", "Total number of relationships in the graph") 187 187 + .namespace("gigabrain") 188 188 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create relationships total gauge: {}", e)))?; 189 189 + 190 190 + let memory_usage_bytes = Gauge::with_opts( 191 191 + Opts::new("gigabrain_memory_usage_bytes", "Memory usage in bytes") 192 192 + .namespace("gigabrain") 193 193 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create memory usage gauge: {}", e)))?; 194 194 + 195 195 + // API metrics 196 196 + let http_requests_total = Counter::with_opts( 197 197 + Opts::new("gigabrain_http_requests_total", "Total number of HTTP requests") 198 198 + .namespace("gigabrain") 199 199 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create HTTP requests counter: {}", e)))?; 200 200 + 201 201 + let http_request_duration = Histogram::with_opts( 202 202 + HistogramOpts::new("gigabrain_http_request_duration_seconds", "Duration of HTTP requests") 203 203 + .namespace("gigabrain") 204 204 + .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]) 205 205 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create HTTP request duration histogram: {}", e)))?; 206 206 + 207 207 + let http_response_size = Histogram::with_opts( 208 208 + HistogramOpts::new("gigabrain_http_response_size_bytes", "Size of HTTP responses in bytes") 209 209 + .namespace("gigabrain") 210 210 + .buckets(vec![100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0]) 211 211 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create HTTP response size histogram: {}", e)))?; 212 212 + 213 213 + // Performance metrics 214 214 + let throughput_ops_per_second = Gauge::with_opts( 215 215 + Opts::new("gigabrain_throughput_ops_per_second", "Current throughput in operations per second") 216 216 + .namespace("gigabrain") 217 217 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create throughput gauge: {}", e)))?; 218 218 + 219 219 + let latency_p95 = Gauge::with_opts( 220 220 + Opts::new("gigabrain_latency_p95_seconds", "95th percentile latency in seconds") 221 221 + .namespace("gigabrain") 222 222 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create latency p95 gauge: {}", e)))?; 223 223 + 224 224 + let latency_p99 = Gauge::with_opts( 225 225 + Opts::new("gigabrain_latency_p99_seconds", "99th percentile latency in seconds") 226 226 + .namespace("gigabrain") 227 227 + ).map_err(|e| GigabrainError::Storage(format!("Failed to create latency p99 gauge: {}", e)))?; 228 228 + 229 229 + Ok(Self { 230 230 + registry, 231 231 + node_operations_total, 232 232 + node_operation_duration, 233 233 + node_operation_errors, 234 234 + relationship_operations_total, 235 235 + relationship_operation_duration, 236 236 + relationship_operation_errors, 237 237 + query_executions_total, 238 238 + query_duration, 239 239 + query_result_count, 240 240 + nodes_total, 241 241 + relationships_total, 242 242 + memory_usage_bytes, 243 243 + http_requests_total, 244 244 + http_request_duration, 245 245 + http_response_size, 246 246 + throughput_ops_per_second, 247 247 + latency_p95, 248 248 + latency_p99, 249 249 + }) 250 250 + } 251 251 + 252 252 + pub fn register_metrics(&self) -> GigabrainResult<()> { 253 253 + self.registry.register(Box::new(self.node_operations_total.clone())) 254 254 + .map_err(|e| GigabrainError::Storage(format!("Failed to register node operations counter: {}", e)))?; 255 255 + self.registry.register(Box::new(self.node_operation_duration.clone())) 256 256 + .map_err(|e| GigabrainError::Storage(format!("Failed to register node operation duration histogram: {}", e)))?; 257 257 + self.registry.register(Box::new(self.node_operation_errors.clone())) 258 258 + .map_err(|e| GigabrainError::Storage(format!("Failed to register node operation errors counter: {}", e)))?; 259 259 + 260 260 + self.registry.register(Box::new(self.relationship_operations_total.clone())) 261 261 + .map_err(|e| GigabrainError::Storage(format!("Failed to register relationship operations counter: {}", e)))?; 262 262 + self.registry.register(Box::new(self.relationship_operation_duration.clone())) 263 263 + .map_err(|e| GigabrainError::Storage(format!("Failed to register relationship operation duration histogram: {}", e)))?; 264 264 + self.registry.register(Box::new(self.relationship_operation_errors.clone())) 265 265 + .map_err(|e| GigabrainError::Storage(format!("Failed to register relationship operation errors counter: {}", e)))?; 266 266 + 267 267 + self.registry.register(Box::new(self.query_executions_total.clone())) 268 268 + .map_err(|e| GigabrainError::Storage(format!("Failed to register query executions counter: {}", e)))?; 269 269 + self.registry.register(Box::new(self.query_duration.clone())) 270 270 + .map_err(|e| GigabrainError::Storage(format!("Failed to register query duration histogram: {}", e)))?; 271 271 + self.registry.register(Box::new(self.query_result_count.clone())) 272 272 + .map_err(|e| GigabrainError::Storage(format!("Failed to register query result count histogram: {}", e)))?; 273 273 + 274 274 + self.registry.register(Box::new(self.nodes_total.clone())) 275 275 + .map_err(|e| GigabrainError::Storage(format!("Failed to register nodes total gauge: {}", e)))?; 276 276 + self.registry.register(Box::new(self.relationships_total.clone())) 277 277 + .map_err(|e| GigabrainError::Storage(format!("Failed to register relationships total gauge: {}", e)))?; 278 278 + self.registry.register(Box::new(self.memory_usage_bytes.clone())) 279 279 + .map_err(|e| GigabrainError::Storage(format!("Failed to register memory usage gauge: {}", e)))?; 280 280 + 281 281 + self.registry.register(Box::new(self.http_requests_total.clone())) 282 282 + .map_err(|e| GigabrainError::Storage(format!("Failed to register HTTP requests counter: {}", e)))?; 283 283 + self.registry.register(Box::new(self.http_request_duration.clone())) 284 284 + .map_err(|e| GigabrainError::Storage(format!("Failed to register HTTP request duration histogram: {}", e)))?; 285 285 + self.registry.register(Box::new(self.http_response_size.clone())) 286 286 + .map_err(|e| GigabrainError::Storage(format!("Failed to register HTTP response size histogram: {}", e)))?; 287 287 + 288 288 + self.registry.register(Box::new(self.throughput_ops_per_second.clone())) 289 289 + .map_err(|e| GigabrainError::Storage(format!("Failed to register throughput gauge: {}", e)))?; 290 290 + self.registry.register(Box::new(self.latency_p95.clone())) 291 291 + .map_err(|e| GigabrainError::Storage(format!("Failed to register latency p95 gauge: {}", e)))?; 292 292 + self.registry.register(Box::new(self.latency_p99.clone())) 293 293 + .map_err(|e| GigabrainError::Storage(format!("Failed to register latency p99 gauge: {}", e)))?; 294 294 + 295 295 + info!("All metrics registered successfully"); 296 296 + Ok(()) 297 297 + } 298 298 + 299 299 + pub fn record_node_operation(&self, operation: &str, duration: Duration, success: bool) { 300 300 + self.node_operations_total.inc(); 301 301 + self.node_operation_duration.observe(duration.as_secs_f64()); 302 302 + 303 303 + if !success { 304 304 + self.node_operation_errors.inc(); 305 305 + } 306 306 + 307 307 + debug!("Recorded node operation: {} ({}ms, success: {})", 308 308 + operation, duration.as_millis(), success); 309 309 + } 310 310 + 311 311 + pub fn record_relationship_operation(&self, operation: &str, duration: Duration, success: bool) { 312 312 + self.relationship_operations_total.inc(); 313 313 + self.relationship_operation_duration.observe(duration.as_secs_f64()); 314 314 + 315 315 + if !success { 316 316 + self.relationship_operation_errors.inc(); 317 317 + } 318 318 + 319 319 + debug!("Recorded relationship operation: {} ({}ms, success: {})", 320 320 + operation, duration.as_millis(), success); 321 321 + } 322 322 + 323 323 + pub fn record_query_execution(&self, query_type: &str, duration: Duration, result_count: usize) { 324 324 + self.query_executions_total.inc(); 325 325 + self.query_duration.observe(duration.as_secs_f64()); 326 326 + self.query_result_count.observe(result_count as f64); 327 327 + 328 328 + debug!("Recorded query execution: {} ({}ms, {} results)", 329 329 + query_type, duration.as_millis(), result_count); 330 330 + } 331 331 + 332 332 + pub fn record_http_request(&self, method: &str, path: &str, duration: Duration, response_size: usize, status_code: u16) { 333 333 + self.http_requests_total.inc(); 334 334 + self.http_request_duration.observe(duration.as_secs_f64()); 335 335 + self.http_response_size.observe(response_size as f64); 336 336 + 337 337 + debug!("Recorded HTTP request: {} {} ({}ms, {} bytes, status: {})", 338 338 + method, path, duration.as_millis(), response_size, status_code); 339 339 + } 340 340 + 341 341 + pub fn update_system_metrics(&self, node_count: u64, relationship_count: u64, memory_usage: u64) { 342 342 + self.nodes_total.set(node_count as f64); 343 343 + self.relationships_total.set(relationship_count as f64); 344 344 + self.memory_usage_bytes.set(memory_usage as f64); 345 345 + } 346 346 + 347 347 + pub fn update_performance_metrics(&self, throughput: f64, latency_p95: f64, latency_p99: f64) { 348 348 + self.throughput_ops_per_second.set(throughput); 349 349 + self.latency_p95.set(latency_p95); 350 350 + self.latency_p99.set(latency_p99); 351 351 + } 352 352 + 353 353 + pub fn get_registry(&self) -> &Registry { 354 354 + &self.registry 355 355 + } 356 356 + } 357 357 + 358 358 + /// Health monitoring system 359 359 + #[derive(Clone)] 360 360 + pub struct HealthMonitor { 361 361 + status: Arc<RwLock<HealthStatus>>, 362 362 + checks: Arc<RwLock<HashMap<String, HealthCheck>>>, 363 363 + } 364 364 + 365 365 + #[derive(Debug, Clone)] 366 366 + pub struct HealthStatus { 367 367 + pub overall: HealthLevel, 368 368 + pub components: HashMap<String, ComponentHealth>, 369 369 + pub last_updated: Instant, 370 370 + } 371 371 + 372 372 + #[derive(Debug, Clone)] 373 373 + pub struct ComponentHealth { 374 374 + pub status: HealthLevel, 375 375 + pub message: String, 376 376 + pub last_check: Instant, 377 377 + } 378 378 + 379 379 + #[derive(Debug, Clone, PartialEq)] 380 380 + pub enum HealthLevel { 381 381 + Healthy, 382 382 + Warning, 383 383 + Critical, 384 384 + Unknown, 385 385 + } 386 386 + 387 387 + #[derive(Clone)] 388 388 + pub struct HealthCheck { 389 389 + pub name: String, 390 390 + pub check_fn: Arc<dyn Fn() -> HealthLevel + Send + Sync>, 391 391 + pub interval: Duration, 392 392 + } 393 393 + 394 394 + impl HealthMonitor { 395 395 + pub fn new() -> Self { 396 396 + let status = HealthStatus { 397 397 + overall: HealthLevel::Unknown, 398 398 + components: HashMap::new(), 399 399 + last_updated: Instant::now(), 400 400 + }; 401 401 + 402 402 + Self { 403 403 + status: Arc::new(RwLock::new(status)), 404 404 + checks: Arc::new(RwLock::new(HashMap::new())), 405 405 + } 406 406 + } 407 407 + 408 408 + pub async fn start_health_checks(&self) { 409 409 + info!("Starting health monitoring system"); 410 410 + 411 411 + // Add default health checks 412 412 + self.add_health_check("memory", || { 413 413 + // Simple memory check - could be enhanced with actual memory monitoring 414 414 + HealthLevel::Healthy 415 415 + }, Duration::from_secs(30)); 416 416 + 417 417 + self.add_health_check("disk_space", || { 418 418 + // Simple disk space check - could be enhanced with actual disk monitoring 419 419 + HealthLevel::Healthy 420 420 + }, Duration::from_secs(60)); 421 421 + 422 422 + // Start health check loop 423 423 + let status = self.status.clone(); 424 424 + let checks = self.checks.clone(); 425 425 + 426 426 + tokio::spawn(async move { 427 427 + let mut interval = tokio::time::interval(Duration::from_secs(10)); 428 428 + loop { 429 429 + interval.tick().await; 430 430 + Self::run_health_checks(&status, &checks).await; 431 431 + } 432 432 + }); 433 433 + } 434 434 + 435 435 + pub fn add_health_check<F>(&self, name: &str, check_fn: F, interval: Duration) 436 436 + where 437 437 + F: Fn() -> HealthLevel + Send + Sync + 'static, 438 438 + { 439 439 + let check = HealthCheck { 440 440 + name: name.to_string(), 441 441 + check_fn: Arc::new(check_fn), 442 442 + interval, 443 443 + }; 444 444 + 445 445 + self.checks.write().insert(name.to_string(), check); 446 446 + info!("Added health check: {}", name); 447 447 + } 448 448 + 449 449 + async fn run_health_checks( 450 450 + status: &Arc<RwLock<HealthStatus>>, 451 451 + checks: &Arc<RwLock<HashMap<String, HealthCheck>>>, 452 452 + ) { 453 453 + let checks = checks.read().clone(); 454 454 + let mut component_healths = HashMap::new(); 455 455 + let mut overall_status = HealthLevel::Healthy; 456 456 + 457 457 + for (name, check) in checks { 458 458 + let health_level = (check.check_fn)(); 459 459 + 460 460 + let component_health = ComponentHealth { 461 461 + status: health_level.clone(), 462 462 + message: format!("{} check completed", name), 463 463 + last_check: Instant::now(), 464 464 + }; 465 465 + 466 466 + // Update overall status based on component status 467 467 + match health_level { 468 468 + HealthLevel::Critical => overall_status = HealthLevel::Critical, 469 469 + HealthLevel::Warning if overall_status != HealthLevel::Critical => { 470 470 + overall_status = HealthLevel::Warning; 471 471 + } 472 472 + _ => {} 473 473 + } 474 474 + 475 475 + component_healths.insert(name, component_health); 476 476 + } 477 477 + 478 478 + let mut status_guard = status.write(); 479 479 + status_guard.overall = overall_status; 480 480 + status_guard.components = component_healths; 481 481 + status_guard.last_updated = Instant::now(); 482 482 + } 483 483 + 484 484 + pub fn get_status(&self) -> HealthStatus { 485 485 + self.status.read().clone() 486 486 + } 487 487 + } 488 488 + 489 489 + /// Performance tracking and analytics 490 490 + pub struct PerformanceTracker { 491 491 + operation_times: Arc<RwLock<Vec<(String, Duration)>>>, 492 492 + query_times: Arc<RwLock<Vec<(String, Duration, usize)>>>, 493 493 + start_time: Instant, 494 494 + operation_count: AtomicU64, 495 495 + total_duration: AtomicU64, 496 496 + } 497 497 + 498 498 + #[derive(Debug, Clone)] 499 499 + pub struct PerformanceStats { 500 500 + pub total_operations: u64, 501 501 + pub average_latency: Duration, 502 502 + pub operations_per_second: f64, 503 503 + pub p95_latency: Duration, 504 504 + pub p99_latency: Duration, 505 505 + pub uptime: Duration, 506 506 + } 507 507 + 508 508 + impl PerformanceTracker { 509 509 + pub fn new() -> Self { 510 510 + Self { 511 511 + operation_times: Arc::new(RwLock::new(Vec::new())), 512 512 + query_times: Arc::new(RwLock::new(Vec::new())), 513 513 + start_time: Instant::now(), 514 514 + operation_count: AtomicU64::new(0), 515 515 + total_duration: AtomicU64::new(0), 516 516 + } 517 517 + } 518 518 + 519 519 + pub fn start_collection(&self) { 520 520 + info!("Starting performance tracking"); 521 521 + 522 522 + // Start periodic performance calculation 523 523 + let operation_times = self.operation_times.clone(); 524 524 + 525 525 + tokio::spawn(async move { 526 526 + let mut interval = tokio::time::interval(Duration::from_secs(60)); 527 527 + loop { 528 528 + interval.tick().await; 529 529 + // Simplified performance calculation 530 530 + let times = operation_times.read(); 531 531 + if !times.is_empty() { 532 532 + debug!("Performance check - {} operations recorded", times.len()); 533 533 + } 534 534 + } 535 535 + }); 536 536 + } 537 537 + 538 538 + pub fn record_operation(&self, operation: &str, duration: Duration) { 539 539 + self.operation_count.fetch_add(1, Ordering::Relaxed); 540 540 + self.total_duration.fetch_add(duration.as_nanos() as u64, Ordering::Relaxed); 541 541 + 542 542 + let mut times = self.operation_times.write(); 543 543 + times.push((operation.to_string(), duration)); 544 544 + 545 545 + // Keep only recent operations (last 1000) 546 546 + if times.len() > 1000 { 547 547 + times.drain(0..500); 548 548 + } 549 549 + } 550 550 + 551 551 + pub fn record_query(&self, query_type: &str, duration: Duration, result_count: usize) { 552 552 + let mut times = self.query_times.write(); 553 553 + times.push((query_type.to_string(), duration, result_count)); 554 554 + 555 555 + // Keep only recent queries (last 500) 556 556 + if times.len() > 500 { 557 557 + times.drain(0..250); 558 558 + } 559 559 + } 560 560 + 561 561 + fn calculate_performance_metrics( 562 562 + operation_times: &Arc<RwLock<Vec<(String, Duration)>>>, 563 563 + _operation_count: &AtomicU64, 564 564 + _total_duration: &AtomicU64, 565 565 + ) { 566 566 + let times = operation_times.read(); 567 567 + if times.is_empty() { 568 568 + return; 569 569 + } 570 570 + 571 571 + let mut durations: Vec<Duration> = times.iter().map(|(_, d)| *d).collect(); 572 572 + durations.sort(); 573 573 + 574 574 + let count = durations.len(); 575 575 + let p95_index = (count as f64 * 0.95) as usize; 576 576 + let p99_index = (count as f64 * 0.99) as usize; 577 577 + 578 578 + let p95_latency = durations.get(p95_index).unwrap_or(&Duration::ZERO); 579 579 + let p99_latency = durations.get(p99_index).unwrap_or(&Duration::ZERO); 580 580 + 581 581 + debug!("Performance metrics - P95: {:?}, P99: {:?}, Operations: {}", 582 582 + p95_latency, p99_latency, count); 583 583 + } 584 584 + 585 585 + pub fn get_stats(&self) -> PerformanceStats { 586 586 + let operation_count = self.operation_count.load(Ordering::Relaxed); 587 587 + let total_duration_nanos = self.total_duration.load(Ordering::Relaxed); 588 588 + let uptime = self.start_time.elapsed(); 589 589 + 590 590 + let average_latency = if operation_count > 0 { 591 591 + Duration::from_nanos(total_duration_nanos / operation_count) 592 592 + } else { 593 593 + Duration::ZERO 594 594 + }; 595 595 + 596 596 + let operations_per_second = if uptime.as_secs() > 0 { 597 597 + operation_count as f64 / uptime.as_secs_f64() 598 598 + } else { 599 599 + 0.0 600 600 + }; 601 601 + 602 602 + // Calculate percentiles from recent operations 603 603 + let times = self.operation_times.read(); 604 604 + let mut durations: Vec<Duration> = times.iter().map(|(_, d)| *d).collect(); 605 605 + durations.sort(); 606 606 + 607 607 + let count = durations.len(); 608 608 + let p95_latency = if count > 0 { 609 609 + let p95_index = (count as f64 * 0.95) as usize; 610 610 + *durations.get(p95_index).unwrap_or(&Duration::ZERO) 611 611 + } else { 612 612 + Duration::ZERO 613 613 + }; 614 614 + 615 615 + let p99_latency = if count > 0 { 616 616 + let p99_index = (count as f64 * 0.99) as usize; 617 617 + *durations.get(p99_index).unwrap_or(&Duration::ZERO) 618 618 + } else { 619 619 + Duration::ZERO 620 620 + }; 621 621 + 622 622 + PerformanceStats { 623 623 + total_operations: operation_count, 624 624 + average_latency, 625 625 + operations_per_second, 626 626 + p95_latency, 627 627 + p99_latency, 628 628 + uptime, 629 629 + } 630 630 + } 631 631 + } 632 632 + 633 633 + impl Default for ObservabilitySystem { 634 634 + fn default() -> Self { 635 635 + Self::new().expect("Failed to create observability system") 636 636 + } 637 637 + }

+133

src/observability/tracing_setup.rs

reviewed

··· 1 1 + use tracing::{info, warn}; 2 2 + use tracing_subscriber::{ 3 3 + fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, 4 4 + }; 5 5 + use std::env; 6 6 + 7 7 + /// Initialize simplified tracing (without OpenTelemetry for compatibility) 8 8 + pub fn init_tracing() -> Result<(), Box<dyn std::error::Error + Send + Sync>> { 9 9 + // Configure tracing subscriber 10 10 + let env_filter = EnvFilter::try_from_default_env() 11 11 + .unwrap_or_else(|_| EnvFilter::new("gigabrain=debug,info")); 12 12 + 13 13 + // Create formatting layer 14 14 + let fmt_layer = fmt::layer() 15 15 + .with_target(true) 16 16 + .with_file(true) 17 17 + .with_line_number(true) 18 18 + .with_thread_ids(true) 19 19 + .with_thread_names(true) 20 20 + .compact(); 21 21 + 22 22 + // Initialize subscriber with basic logging 23 23 + tracing_subscriber::registry() 24 24 + .with(env_filter) 25 25 + .with(fmt_layer) 26 26 + .init(); 27 27 + 28 28 + info!("Tracing system initialized successfully"); 29 29 + Ok(()) 30 30 + } 31 31 + 32 32 + /// Setup structured logging with JSON output for production 33 33 + pub fn init_structured_logging() { 34 34 + let env_filter = EnvFilter::try_from_default_env() 35 35 + .unwrap_or_else(|_| EnvFilter::new("gigabrain=info")); 36 36 + 37 37 + let subscriber = tracing_subscriber::fmt() 38 38 + .with_env_filter(env_filter) 39 39 + .json() 40 40 + .with_current_span(true) 41 41 + .with_span_list(true) 42 42 + .with_target(true) 43 43 + .with_file(true) 44 44 + .with_line_number(true) 45 45 + .with_thread_ids(true) 46 46 + .with_thread_names(true) 47 47 + .finish(); 48 48 + 49 49 + tracing::subscriber::set_global_default(subscriber) 50 50 + .expect("Failed to set tracing subscriber"); 51 51 + 52 52 + info!("Structured JSON logging initialized"); 53 53 + } 54 54 + 55 55 + /// Setup development-friendly logging 56 56 + pub fn init_dev_logging() { 57 57 + let env_filter = EnvFilter::try_from_default_env() 58 58 + .unwrap_or_else(|_| EnvFilter::new("gigabrain=debug")); 59 59 + 60 60 + tracing_subscriber::fmt() 61 61 + .with_env_filter(env_filter) 62 62 + .with_target(true) 63 63 + .with_file(true) 64 64 + .with_line_number(true) 65 65 + .with_thread_ids(true) 66 66 + .with_thread_names(true) 67 67 + .pretty() 68 68 + .init(); 69 69 + 70 70 + info!("Development logging initialized"); 71 71 + } 72 72 + 73 73 + /// Initialize logging based on environment 74 74 + pub fn init_environment_logging() { 75 75 + let env = env::var("GIGABRAIN_ENV").unwrap_or_else(|_| "development".to_string()); 76 76 + 77 77 + match env.to_lowercase().as_str() { 78 78 + "production" | "prod" => { 79 79 + init_structured_logging(); 80 80 + info!("Production logging mode enabled"); 81 81 + } 82 82 + "development" | "dev" => { 83 83 + init_dev_logging(); 84 84 + info!("Development logging mode enabled"); 85 85 + } 86 86 + _ => { 87 87 + init_dev_logging(); 88 88 + warn!("Unknown environment '{}', defaulting to development logging", env); 89 89 + } 90 90 + } 91 91 + } 92 92 + 93 93 + /// Create a new tracing span for request tracking 94 94 + #[macro_export] 95 95 + macro_rules! trace_request { 96 96 + ($name:expr, $($key:expr => $value:expr),*) => { 97 97 + tracing::info_span!( 98 98 + $name, 99 99 + $($key = $value,)* 100 100 + request_id = %uuid::Uuid::new_v4() 101 101 + ) 102 102 + }; 103 103 + } 104 104 + 105 105 + /// Create a new tracing span for operation tracking 106 106 + #[macro_export] 107 107 + macro_rules! trace_operation { 108 108 + ($name:expr, $($key:expr => $value:expr),*) => { 109 109 + tracing::debug_span!( 110 110 + $name, 111 111 + $($key = $value,)* 112 112 + operation_id = %uuid::Uuid::new_v4() 113 113 + ) 114 114 + }; 115 115 + } 116 116 + 117 117 + #[cfg(test)] 118 118 + mod tests { 119 119 + use super::*; 120 120 + 121 121 + #[test] 122 122 + fn test_dev_logging_init() { 123 123 + // Test that development logging can be initialized without panicking 124 124 + init_dev_logging(); 125 125 + } 126 126 + 127 127 + #[test] 128 128 + fn test_environment_logging_init() { 129 129 + // Test that environment-based logging can be initialized 130 130 + std::env::set_var("GIGABRAIN_ENV", "development"); 131 131 + init_environment_logging(); 132 132 + } 133 133 + }

+77 -1

src/server/rest.rs

reviewed

··· 1 1 use super::ServerConfig; 2 2 use crate::{Graph, Result as GigabrainResult, GigabrainError, algorithms::GraphAlgorithms}; 3 3 + use crate::observability::{ObservabilitySystem, HealthLevel}; 3 4 use axum::{ 4 5 extract::{Path, Query, State}, 5 6 http::StatusCode, 6 6 - response::Json, 7 7 + response::{Json, Response}, 7 8 routing::{delete, get, post, put}, 8 9 Router, 9 10 }; ··· 75 76 76 77 // Documentation 77 78 .route("/api/v1/docs", get(api_docs)) 79 79 + 80 80 + // Observability endpoints 81 81 + .route("/metrics", get(get_metrics)) 82 82 + .route("/api/v1/health", get(get_detailed_health)) 78 83 79 84 .with_state(self.graph) 80 85 .layer(CorsLayer::permissive()) ··· 1277 1282 crate::core::PropertyValue::List(_) => serde_json::Value::String("list".to_string()), 1278 1283 crate::core::PropertyValue::Map(_) => serde_json::Value::String("map".to_string()), 1279 1284 } 1285 1285 + } 1286 1286 + 1287 1287 + // Observability handlers 1288 1288 + 1289 1289 + async fn get_metrics() -> Result<Response, (StatusCode, Json<ErrorResponse>)> { 1290 1290 + // Get prometheus metrics in text format 1291 1291 + let encoder = prometheus::TextEncoder::new(); 1292 1292 + let metric_families = prometheus::gather(); 1293 1293 + 1294 1294 + match encoder.encode_to_string(&metric_families) { 1295 1295 + Ok(output) => { 1296 1296 + let response = Response::builder() 1297 1297 + .status(StatusCode::OK) 1298 1298 + .header("content-type", "text/plain; version=0.0.4; charset=utf-8") 1299 1299 + .body(output.into()) 1300 1300 + .map_err(|_| ( 1301 1301 + StatusCode::INTERNAL_SERVER_ERROR, 1302 1302 + Json(ErrorResponse { 1303 1303 + error: "Failed to build response".to_string(), 1304 1304 + code: 500, 1305 1305 + }), 1306 1306 + ))?; 1307 1307 + Ok(response) 1308 1308 + }, 1309 1309 + Err(e) => Err(( 1310 1310 + StatusCode::INTERNAL_SERVER_ERROR, 1311 1311 + Json(ErrorResponse { 1312 1312 + error: format!("Failed to encode metrics: {}", e), 1313 1313 + code: 500, 1314 1314 + }), 1315 1315 + )), 1316 1316 + } 1317 1317 + } 1318 1318 + 1319 1319 + async fn get_detailed_health( 1320 1320 + State(graph): State<Arc<Graph>>, 1321 1321 + ) -> Result<Json<serde_json::Value>, (StatusCode, Json<ErrorResponse>)> { 1322 1322 + // Create a comprehensive health report 1323 1323 + let health_checker = crate::observability::health::HealthChecker::new(); 1324 1324 + let health_report = health_checker.generate_health_report(); 1325 1325 + 1326 1326 + // Add graph-specific health information 1327 1327 + let mut health_json = serde_json::to_value(&health_report) 1328 1328 + .map_err(|e| ( 1329 1329 + StatusCode::INTERNAL_SERVER_ERROR, 1330 1330 + Json(ErrorResponse { 1331 1331 + error: format!("Failed to serialize health report: {}", e), 1332 1332 + code: 500, 1333 1333 + }), 1334 1334 + ))?; 1335 1335 + 1336 1336 + // Add graph statistics to health report 1337 1337 + if let Some(obj) = health_json.as_object_mut() { 1338 1338 + let stats = crate::algorithms::GraphAlgorithms::get_stats(&graph); 1339 1339 + obj.insert("graph_stats".to_string(), serde_json::json!({ 1340 1340 + "node_count": stats.node_count, 1341 1341 + "relationship_count": stats.relationship_count, 1342 1342 + "label_count": stats.label_count, 1343 1343 + "property_key_count": stats.property_key_count, 1344 1344 + "relationship_type_count": stats.relationship_type_count 1345 1345 + })); 1346 1346 + 1347 1347 + // Add memory usage estimate 1348 1348 + obj.insert("graph_memory".to_string(), serde_json::json!({ 1349 1349 + "estimated_size_bytes": stats.node_count * 64 + stats.relationship_count * 48, // Rough estimate 1350 1350 + "nodes_in_memory": stats.node_count, 1351 1351 + "relationships_in_memory": stats.relationship_count 1352 1352 + })); 1353 1353 + } 1354 1354 + 1355 1355 + Ok(Json(health_json)) 1280 1356 }

+505

tests/integration_tests.rs

reviewed

··· 1 1 + use std::sync::Arc; 2 2 + use std::time::Duration; 3 3 + use tokio::time::sleep; 4 4 + use serde_json::{json, Value}; 5 5 + use reqwest::{Client, Response}; 6 6 + use gigabrain::Graph; 7 7 + use gigabrain::server::{ServerConfig, rest::RestServer}; 8 8 + 9 9 + /// Integration test client for HTTP API testing 10 10 + #[derive(Clone)] 11 11 + pub struct TestClient { 12 12 + client: Client, 13 13 + base_url: String, 14 14 + } 15 15 + 16 16 + impl TestClient { 17 17 + pub fn new(base_url: &str) -> Self { 18 18 + Self { 19 19 + client: Client::new(), 20 20 + base_url: base_url.to_string(), 21 21 + } 22 22 + } 23 23 + 24 24 + /// Helper to make GET requests 25 25 + pub async fn get(&self, path: &str) -> Result<Response, reqwest::Error> { 26 26 + self.client 27 27 + .get(&format!("{}{}", self.base_url, path)) 28 28 + .send() 29 29 + .await 30 30 + } 31 31 + 32 32 + /// Helper to make POST requests with JSON body 33 33 + pub async fn post_json(&self, path: &str, body: Value) -> Result<Response, reqwest::Error> { 34 34 + self.client 35 35 + .post(&format!("{}{}", self.base_url, path)) 36 36 + .header("Content-Type", "application/json") 37 37 + .json(&body) 38 38 + .send() 39 39 + .await 40 40 + } 41 41 + 42 42 + /// Helper to make PUT requests with JSON body 43 43 + pub async fn put_json(&self, path: &str, body: Value) -> Result<Response, reqwest::Error> { 44 44 + self.client 45 45 + .put(&format!("{}{}", self.base_url, path)) 46 46 + .header("Content-Type", "application/json") 47 47 + .json(&body) 48 48 + .send() 49 49 + .await 50 50 + } 51 51 + 52 52 + /// Helper to make DELETE requests 53 53 + pub async fn delete(&self, path: &str) -> Result<Response, reqwest::Error> { 54 54 + self.client 55 55 + .delete(&format!("{}{}", self.base_url, path)) 56 56 + .send() 57 57 + .await 58 58 + } 59 59 + } 60 60 + 61 61 + /// Test server manager for integration tests 62 62 + pub struct TestServer { 63 63 + _handle: tokio::task::JoinHandle<()>, 64 64 + base_url: String, 65 65 + port: u16, 66 66 + } 67 67 + 68 68 + impl TestServer { 69 69 + /// Start a test server on a random available port 70 70 + pub async fn start() -> Result<Self, Box<dyn std::error::Error>> { 71 71 + use std::net::TcpListener; 72 72 + 73 73 + // Find an available port 74 74 + let listener = TcpListener::bind("127.0.0.1:0")?; 75 75 + let port = listener.local_addr()?.port(); 76 76 + drop(listener); 77 77 + 78 78 + let graph = Arc::new(Graph::new()); 79 79 + let config = ServerConfig::default(); 80 80 + let server = RestServer::new(graph, config); 81 81 + 82 82 + // Start server in background 83 83 + let handle = tokio::spawn(async move { 84 84 + if let Err(e) = server.serve(port).await { 85 85 + eprintln!("Test server error: {}", e); 86 86 + } 87 87 + }); 88 88 + 89 89 + // Wait a bit for server to start 90 90 + sleep(Duration::from_millis(100)).await; 91 91 + 92 92 + let base_url = format!("http://localhost:{}", port); 93 93 + 94 94 + Ok(Self { 95 95 + _handle: handle, 96 96 + base_url, 97 97 + port, 98 98 + }) 99 99 + } 100 100 + 101 101 + pub fn client(&self) -> TestClient { 102 102 + TestClient::new(&self.base_url) 103 103 + } 104 104 + 105 105 + pub fn port(&self) -> u16 { 106 106 + self.port 107 107 + } 108 108 + } 109 109 + 110 110 + #[cfg(test)] 111 111 + mod tests { 112 112 + use super::*; 113 113 + use serde_json::json; 114 114 + 115 115 + /// Helper to start test server for each test 116 116 + async fn setup() -> TestClient { 117 117 + let server = TestServer::start().await.expect("Failed to start test server"); 118 118 + server.client() 119 119 + } 120 120 + 121 121 + #[tokio::test] 122 122 + async fn test_health_check() { 123 123 + let client = setup().await; 124 124 + 125 125 + let response = client.get("/health").await.expect("Request failed"); 126 126 + assert_eq!(response.status(), 200); 127 127 + 128 128 + let body: Value = response.json().await.expect("Failed to parse JSON"); 129 129 + assert_eq!(body["status"], "healthy"); 130 130 + assert!(body["version"].is_string()); 131 131 + } 132 132 + 133 133 + #[tokio::test] 134 134 + async fn test_node_crud_operations() { 135 135 + let client = setup().await; 136 136 + 137 137 + // Create a node 138 138 + let create_request = json!({ 139 139 + "labels": ["Person", "Employee"], 140 140 + "properties": { 141 141 + "name": "John Doe", 142 142 + "age": 30, 143 143 + "active": true, 144 144 + "salary": 75000 145 145 + } 146 146 + }); 147 147 + 148 148 + let response = client.post_json("/api/v1/nodes", create_request).await.expect("Create failed"); 149 149 + assert_eq!(response.status(), 200); 150 150 + 151 151 + let create_body: Value = response.json().await.expect("Failed to parse JSON"); 152 152 + let node_id = create_body["node_id"].as_u64().expect("node_id should be number"); 153 153 + 154 154 + // Get the node 155 155 + let response = client.get(&format!("/api/v1/nodes/{}", node_id)).await.expect("Get failed"); 156 156 + assert_eq!(response.status(), 200); 157 157 + 158 158 + let get_body: Value = response.json().await.expect("Failed to parse JSON"); 159 159 + assert_eq!(get_body["id"], node_id); 160 160 + assert_eq!(get_body["labels"], json!(["Person", "Employee"])); 161 161 + assert_eq!(get_body["properties"]["name"], "John Doe"); 162 162 + assert_eq!(get_body["properties"]["age"], 30); 163 163 + assert_eq!(get_body["properties"]["active"], true); 164 164 + assert_eq!(get_body["properties"]["salary"], 75000); 165 165 + 166 166 + // Update the node 167 167 + let update_request = json!({ 168 168 + "labels": ["Person", "Manager"], 169 169 + "properties": { 170 170 + "title": "Engineering Manager", 171 171 + "team_size": 5 172 172 + } 173 173 + }); 174 174 + 175 175 + let response = client.put_json(&format!("/api/v1/nodes/{}", node_id), update_request).await.expect("Update failed"); 176 176 + assert_eq!(response.status(), 200); 177 177 + 178 178 + let update_body: Value = response.json().await.expect("Failed to parse JSON"); 179 179 + assert_eq!(update_body["labels"], json!(["Person", "Manager"])); 180 180 + assert_eq!(update_body["properties"]["title"], "Engineering Manager"); 181 181 + assert_eq!(update_body["properties"]["team_size"], 5); 182 182 + // Existing properties should be preserved 183 183 + assert_eq!(update_body["properties"]["name"], "John Doe"); 184 184 + 185 185 + // Delete a specific property 186 186 + let response = client.delete(&format!("/api/v1/nodes/{}/properties/age", node_id)).await.expect("Property delete failed"); 187 187 + assert_eq!(response.status(), 200); 188 188 + 189 189 + let delete_prop_body: Value = response.json().await.expect("Failed to parse JSON"); 190 190 + assert!(delete_prop_body["properties"]["age"].is_null()); 191 191 + assert_eq!(delete_prop_body["properties"]["name"], "John Doe"); 192 192 + 193 193 + // Delete the node 194 194 + let response = client.delete(&format!("/api/v1/nodes/{}", node_id)).await.expect("Delete failed"); 195 195 + assert_eq!(response.status(), 204); 196 196 + 197 197 + // Verify node is deleted 198 198 + let response = client.get(&format!("/api/v1/nodes/{}", node_id)).await.expect("Get failed"); 199 199 + assert_eq!(response.status(), 404); 200 200 + } 201 201 + 202 202 + #[tokio::test] 203 203 + async fn test_relationship_operations() { 204 204 + let client = setup().await; 205 205 + 206 206 + // Create two nodes first 207 207 + let node1_request = json!({ 208 208 + "labels": ["Person"], 209 209 + "properties": {"name": "Alice"} 210 210 + }); 211 211 + let response = client.post_json("/api/v1/nodes", node1_request).await.expect("Create node1 failed"); 212 212 + let node1_id = response.json::<Value>().await.expect("Parse failed")["node_id"].as_u64().unwrap(); 213 213 + 214 214 + let node2_request = json!({ 215 215 + "labels": ["Person"], 216 216 + "properties": {"name": "Bob"} 217 217 + }); 218 218 + let response = client.post_json("/api/v1/nodes", node2_request).await.expect("Create node2 failed"); 219 219 + let node2_id = response.json::<Value>().await.expect("Parse failed")["node_id"].as_u64().unwrap(); 220 220 + 221 221 + // Create relationship 222 222 + let rel_request = json!({ 223 223 + "start_node": node1_id, 224 224 + "end_node": node2_id, 225 225 + "rel_type": "KNOWS", 226 226 + "properties": { 227 227 + "since": "2023-01-01", 228 228 + "strength": 8 229 229 + } 230 230 + }); 231 231 + 232 232 + let response = client.post_json("/api/v1/relationships", rel_request).await.expect("Create relationship failed"); 233 233 + assert_eq!(response.status(), 200); 234 234 + 235 235 + let rel_body: Value = response.json().await.expect("Failed to parse JSON"); 236 236 + let rel_id = rel_body["relationship_id"].as_u64().expect("relationship_id should be number"); 237 237 + 238 238 + // Get the relationship 239 239 + let response = client.get(&format!("/api/v1/relationships/{}", rel_id)).await.expect("Get relationship failed"); 240 240 + assert_eq!(response.status(), 200); 241 241 + 242 242 + let get_rel_body: Value = response.json().await.expect("Failed to parse JSON"); 243 243 + assert_eq!(get_rel_body["id"], rel_id); 244 244 + assert_eq!(get_rel_body["start_node"], node1_id); 245 245 + assert_eq!(get_rel_body["end_node"], node2_id); 246 246 + assert_eq!(get_rel_body["rel_type"], "KNOWS"); 247 247 + 248 248 + // Delete relationship 249 249 + let response = client.delete(&format!("/api/v1/relationships/{}", rel_id)).await.expect("Delete relationship failed"); 250 250 + assert_eq!(response.status(), 204); 251 251 + 252 252 + // Verify relationship is deleted 253 253 + let response = client.get(&format!("/api/v1/relationships/{}", rel_id)).await.expect("Get relationship failed"); 254 254 + assert_eq!(response.status(), 404); 255 255 + } 256 256 + 257 257 + #[tokio::test] 258 258 + async fn test_schema_constraints() { 259 259 + let client = setup().await; 260 260 + 261 261 + // Create required constraint 262 262 + let constraint_request = json!({ 263 263 + "constraint_type": "required", 264 264 + "label": "Employee", 265 265 + "property": "email" 266 266 + }); 267 267 + 268 268 + let response = client.post_json("/api/v1/constraints", constraint_request).await.expect("Create constraint failed"); 269 269 + assert_eq!(response.status(), 200); 270 270 + 271 271 + let constraint_body: Value = response.json().await.expect("Failed to parse JSON"); 272 272 + assert_eq!(constraint_body["constraint_type"], "required"); 273 273 + assert_eq!(constraint_body["label"], "Employee"); 274 274 + assert_eq!(constraint_body["property"], "email"); 275 275 + 276 276 + // Try to create node without required property (should fail) 277 277 + let invalid_node = json!({ 278 278 + "labels": ["Employee"], 279 279 + "properties": {"name": "John Doe"} 280 280 + }); 281 281 + 282 282 + let response = client.post_json("/api/v1/nodes", invalid_node).await.expect("Request failed"); 283 283 + assert_eq!(response.status(), 400); 284 284 + 285 285 + let error_body: Value = response.json().await.expect("Failed to parse JSON"); 286 286 + assert!(error_body["error"].as_str().unwrap().contains("Required property 'email' is missing")); 287 287 + 288 288 + // Create valid node with required property 289 289 + let valid_node = json!({ 290 290 + "labels": ["Employee"], 291 291 + "properties": { 292 292 + "name": "John Doe", 293 293 + "email": "john@example.com" 294 294 + } 295 295 + }); 296 296 + 297 297 + let response = client.post_json("/api/v1/nodes", valid_node).await.expect("Create valid node failed"); 298 298 + assert_eq!(response.status(), 200); 299 299 + } 300 300 + 301 301 + #[tokio::test] 302 302 + async fn test_type_constraints() { 303 303 + let client = setup().await; 304 304 + 305 305 + // Create type constraint 306 306 + let constraint_request = json!({ 307 307 + "constraint_type": "type", 308 308 + "label": "Employee", 309 309 + "property": "salary", 310 310 + "type_value": "integer" 311 311 + }); 312 312 + 313 313 + let response = client.post_json("/api/v1/constraints", constraint_request).await.expect("Create constraint failed"); 314 314 + assert_eq!(response.status(), 200); 315 315 + 316 316 + // Try to create node with wrong type (should fail) 317 317 + let invalid_node = json!({ 318 318 + "labels": ["Employee"], 319 319 + "properties": { 320 320 + "name": "John Doe", 321 321 + "salary": "fifty thousand" 322 322 + } 323 323 + }); 324 324 + 325 325 + let response = client.post_json("/api/v1/nodes", invalid_node).await.expect("Request failed"); 326 326 + assert_eq!(response.status(), 400); 327 327 + 328 328 + let error_body: Value = response.json().await.expect("Failed to parse JSON"); 329 329 + assert!(error_body["error"].as_str().unwrap().contains("wrong type")); 330 330 + 331 331 + // Create valid node with correct type 332 332 + let valid_node = json!({ 333 333 + "labels": ["Employee"], 334 334 + "properties": { 335 335 + "name": "John Doe", 336 336 + "salary": 50000 337 337 + } 338 338 + }); 339 339 + 340 340 + let response = client.post_json("/api/v1/nodes", valid_node).await.expect("Create valid node failed"); 341 341 + assert_eq!(response.status(), 200); 342 342 + } 343 343 + 344 344 + #[tokio::test] 345 345 + async fn test_range_constraints() { 346 346 + let client = setup().await; 347 347 + 348 348 + // Create range constraint 349 349 + let constraint_request = json!({ 350 350 + "constraint_type": "range", 351 351 + "label": "Employee", 352 352 + "property": "salary", 353 353 + "min_value": 30000, 354 354 + "max_value": 200000 355 355 + }); 356 356 + 357 357 + let response = client.post_json("/api/v1/constraints", constraint_request).await.expect("Create constraint failed"); 358 358 + assert_eq!(response.status(), 200); 359 359 + 360 360 + // Try to create node with value out of range (should fail) 361 361 + let invalid_node = json!({ 362 362 + "labels": ["Employee"], 363 363 + "properties": { 364 364 + "name": "John Doe", 365 365 + "salary": 250000 366 366 + } 367 367 + }); 368 368 + 369 369 + let response = client.post_json("/api/v1/nodes", invalid_node).await.expect("Request failed"); 370 370 + assert_eq!(response.status(), 400); 371 371 + 372 372 + let error_body: Value = response.json().await.expect("Failed to parse JSON"); 373 373 + assert!(error_body["error"].as_str().unwrap().contains("out of range")); 374 374 + 375 375 + // Create valid node within range 376 376 + let valid_node = json!({ 377 377 + "labels": ["Employee"], 378 378 + "properties": { 379 379 + "name": "John Doe", 380 380 + "salary": 75000 381 381 + } 382 382 + }); 383 383 + 384 384 + let response = client.post_json("/api/v1/nodes", valid_node).await.expect("Create valid node failed"); 385 385 + assert_eq!(response.status(), 200); 386 386 + } 387 387 + 388 388 + #[tokio::test] 389 389 + async fn test_graph_statistics() { 390 390 + let client = setup().await; 391 391 + 392 392 + // Get initial stats 393 393 + let response = client.get("/api/v1/stats").await.expect("Get stats failed"); 394 394 + assert_eq!(response.status(), 200); 395 395 + 396 396 + let stats: Value = response.json().await.expect("Failed to parse JSON"); 397 397 + let initial_count = stats["node_count"].as_u64().unwrap(); 398 398 + 399 399 + // Create some nodes 400 400 + for i in 0..5 { 401 401 + let node_request = json!({ 402 402 + "labels": ["TestNode"], 403 403 + "properties": {"id": i} 404 404 + }); 405 405 + let response = client.post_json("/api/v1/nodes", node_request).await.expect("Create node failed"); 406 406 + assert_eq!(response.status(), 200); 407 407 + } 408 408 + 409 409 + // Check updated stats 410 410 + let response = client.get("/api/v1/stats").await.expect("Get stats failed"); 411 411 + let stats: Value = response.json().await.expect("Failed to parse JSON"); 412 412 + assert_eq!(stats["node_count"].as_u64().unwrap(), initial_count + 5); 413 413 + 414 414 + let labels = stats["labels"].as_array().unwrap(); 415 415 + assert!(labels.contains(&json!("TestNode"))); 416 416 + } 417 417 + 418 418 + #[tokio::test] 419 419 + async fn test_api_documentation() { 420 420 + let client = setup().await; 421 421 + 422 422 + let response = client.get("/api/v1/docs").await.expect("Get docs failed"); 423 423 + assert_eq!(response.status(), 200); 424 424 + 425 425 + let docs: Value = response.json().await.expect("Failed to parse JSON"); 426 426 + assert_eq!(docs["title"], "GigaBrain Graph Database API"); 427 427 + assert!(docs["endpoints"].is_object()); 428 428 + assert!(docs["endpoints"]["nodes"].is_object()); 429 429 + assert!(docs["endpoints"]["relationships"].is_object()); 430 430 + assert!(docs["endpoints"]["constraints"].is_object()); 431 431 + } 432 432 + 433 433 + #[tokio::test] 434 434 + async fn test_error_handling() { 435 435 + let client = setup().await; 436 436 + 437 437 + // Test non-existent node 438 438 + let response = client.get("/api/v1/nodes/999999").await.expect("Request failed"); 439 439 + assert_eq!(response.status(), 404); 440 440 + 441 441 + let error: Value = response.json().await.expect("Failed to parse JSON"); 442 442 + assert_eq!(error["code"], 404); 443 443 + assert!(error["error"].as_str().unwrap().contains("not found")); 444 444 + 445 445 + // Test malformed JSON 446 446 + let response = client.client 447 447 + .post(&format!("{}/api/v1/nodes", client.base_url)) 448 448 + .header("Content-Type", "application/json") 449 449 + .body("invalid json") 450 450 + .send() 451 451 + .await 452 452 + .expect("Request failed"); 453 453 + assert_eq!(response.status(), 400); 454 454 + 455 455 + // Test non-existent relationship 456 456 + let response = client.get("/api/v1/relationships/999999").await.expect("Request failed"); 457 457 + assert_eq!(response.status(), 404); 458 458 + 459 459 + // Test invalid constraint type 460 460 + let invalid_constraint = json!({ 461 461 + "constraint_type": "invalid_type", 462 462 + "label": "Test", 463 463 + "property": "test" 464 464 + }); 465 465 + 466 466 + let response = client.post_json("/api/v1/constraints", invalid_constraint).await.expect("Request failed"); 467 467 + assert_eq!(response.status(), 400); 468 468 + } 469 469 + 470 470 + #[tokio::test] 471 471 + async fn test_concurrent_operations() { 472 472 + let client = setup().await; 473 473 + 474 474 + // Create multiple nodes concurrently 475 475 + let mut handles = vec![]; 476 476 + 477 477 + for i in 0..10 { 478 478 + let client = client.clone(); 479 479 + let handle = tokio::spawn(async move { 480 480 + let node_request = json!({ 481 481 + "labels": ["ConcurrentTest"], 482 482 + "properties": {"thread_id": i} 483 483 + }); 484 484 + 485 485 + client.post_json("/api/v1/nodes", node_request).await 486 486 + }); 487 487 + handles.push(handle); 488 488 + } 489 489 + 490 490 + // Wait for all to complete 491 491 + let results: Vec<_> = futures::future::join_all(handles).await; 492 492 + 493 493 + // All should succeed 494 494 + for result in results { 495 495 + let response = result.expect("Task failed").expect("Request failed"); 496 496 + assert_eq!(response.status(), 200); 497 497 + } 498 498 + 499 499 + // Verify all nodes were created 500 500 + let response = client.get("/api/v1/stats").await.expect("Get stats failed"); 501 501 + let stats: Value = response.json().await.expect("Failed to parse JSON"); 502 502 + let node_count = stats["node_count"].as_u64().unwrap(); 503 503 + assert!(node_count >= 10); 504 504 + } 505 505 + }