From 4f8b88ebb7145c8d12442cbf1caff153e535a120 Mon Sep 17 00:00:00 2001 From: Demitri Swan Date: Mon, 28 Sep 2020 11:51:15 -0700 Subject: [PATCH] Updates (#28) Updates * Adding .clang-format to keep formatting consistent * Adding regression test for prom_histogram_buckets * Added format command to auto * Formatted project Co-authored-by: Demitri Swan --- .clang-format | 2 + .gitignore | 3 +- README.md | 6 +- auto | 2 +- autolib/cmd/dev | 2 +- autolib/cmd/format | 73 ++++++ autolib/docker.sh | 42 +++- example/example | Bin 0 -> 20016 bytes prom/include/prom_alloc.h | 4 +- prom/include/prom_collector.h | 10 +- prom/include/prom_collector_registry.h | 13 +- prom/include/prom_counter.h | 12 +- prom/include/prom_gauge.h | 12 +- prom/include/prom_histogram.h | 12 +- prom/include/prom_histogram_buckets.h | 11 +- prom/include/prom_linked_list.h | 8 +- prom/include/prom_map.h | 4 +- prom/include/prom_metric.h | 6 +- prom/include/prom_metric_sample.h | 2 +- prom/include/prom_metric_sample_histogram.h | 4 +- prom/src/prom_assert.h | 10 +- prom/src/prom_collector.c | 44 ++-- prom/src/prom_collector_registry.c | 37 ++- prom/src/prom_collector_registry_i.h | 4 +- prom/src/prom_collector_registry_t.h | 15 +- prom/src/prom_collector_t.h | 5 +- prom/src/prom_counter.c | 18 +- prom/src/prom_errors.h | 2 +- prom/src/prom_gauge.c | 17 +- prom/src/prom_histogram.c | 22 +- prom/src/prom_histogram_buckets.c | 27 +-- prom/src/prom_linked_list.c | 29 ++- prom/src/prom_linked_list_i.h | 8 +- prom/src/prom_linked_list_t.h | 16 +- prom/src/prom_log.h | 10 +- prom/src/prom_map.c | 130 +++------- prom/src/prom_map_i.h | 14 +- prom/src/prom_map_t.h | 17 +- prom/src/prom_metric.c | 100 +++----- prom/src/prom_metric_formatter.c | 88 +++---- prom/src/prom_metric_formatter_i.h | 26 +- prom/src/prom_metric_formatter_t.h | 5 +- prom/src/prom_metric_i.h | 10 +- prom/src/prom_metric_sample.c | 18 +- prom/src/prom_metric_sample_histogram.c | 237 ++++++++----------- prom/src/prom_metric_sample_histogram_i.h | 13 +- prom/src/prom_metric_sample_histogram_t.h | 4 +- prom/src/prom_metric_sample_i.h | 9 +- prom/src/prom_metric_sample_t.h | 10 +- prom/src/prom_metric_t.h | 22 +- prom/src/prom_process_fds.c | 17 +- prom/src/prom_process_fds_i.h | 6 +- prom/src/prom_process_fds_t.h | 4 +- prom/src/prom_process_limits.c | 206 +++++++--------- prom/src/prom_process_limits_i.h | 55 +++-- prom/src/prom_process_limits_t.h | 22 +- prom/src/prom_process_stat.c | 250 ++++++++++---------- prom/src/prom_process_stat_i.h | 9 +- prom/src/prom_process_stat_t.h | 110 +++++---- prom/src/prom_procfs.c | 29 +-- prom/src/prom_procfs_i.h | 7 +- prom/src/prom_procfs_t.h | 6 +- prom/src/prom_string_builder.c | 34 ++- prom/src/prom_string_builder_i.h | 14 +- prom/src/prom_string_builder_t.h | 8 +- prom/test/prom_collector_registry_test.c | 42 ++-- prom/test/prom_collector_test.c | 13 +- prom/test/prom_counter_test.c | 20 +- prom/test/prom_gauge_test.c | 41 ++-- prom/test/prom_histogram_buckets_test.c | 11 +- prom/test/prom_histogram_test.c | 34 ++- prom/test/prom_linked_list_test.c | 19 +- prom/test/prom_map_test.c | 32 +-- prom/test/prom_metric_formatter_test.c | 34 +-- prom/test/prom_metric_sample_test.c | 9 +- prom/test/prom_metric_test.c | 19 +- prom/test/prom_process_limits_test.c | 54 ++--- prom/test/prom_procfs_test.c | 4 +- prom/test/prom_string_builder_test.c | 10 +- prom/test/prom_test_helpers.c | 3 +- prom/test/prom_test_helpers.h | 36 ++- promhttp/include/promhttp.h | 12 +- promhttp/src/promhttp.c | 40 +--- promtest/test/promtest.c | 10 +- promtest/test/promtest_counter.c | 12 +- promtest/test/promtest_counter.h | 4 +- promtest/test/promtest_gauge.c | 8 +- promtest/test/promtest_gauge.h | 4 +- promtest/test/promtest_helpers.c | 10 +- promtest/test/promtest_helpers.h | 2 +- 90 files changed, 1099 insertions(+), 1356 deletions(-) create mode 100644 .clang-format create mode 100755 autolib/cmd/format create mode 100755 example/example diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..af4bcf1 --- /dev/null +++ b/.clang-format @@ -0,0 +1,2 @@ +BasedOnStyle: Google +ColumnLimit: 120 \ No newline at end of file diff --git a/.gitignore b/.gitignore index f729b04..9be2177 100644 --- a/.gitignore +++ b/.gitignore @@ -8,4 +8,5 @@ ttyrecord _CPack_Packages/ *deb *tar.gz -*vgcore* \ No newline at end of file +*vgcore* +*.o diff --git a/README.md b/README.md index e532ebb..ffde3bd 100644 --- a/README.md +++ b/README.md @@ -27,8 +27,8 @@ project directory and execute `make`. This process will build the development co run the unit tests and execute the smoke tests. The stages of the development workflow are automated via `auto` which can be found in the root of this project directory. -Execute `./auto -h` for information regarding the different subcommands. Information for each subcommand can be -obtained by executing `./auto CMD -h`. +Execute `bash auto -h` for information regarding the different subcommands. Information for each subcommand can be +obtained by executing `bash auto CMD -h`. ## Contributing @@ -54,7 +54,7 @@ communication process so please do not be shy. Speak up! ### Coding Rules for Contribution * Please follow the general coding style already present in the project. - * clang-format your code with style Google. + * clang-format your code by executing `bash auto format` before submitting a PR. * Every struct must have a constructor function and destructor function. * Every method must pass a pointer to the target struct as the first argument. * Every function that is not a constructor or destructor and does not return a value must return an int to signify diff --git a/auto b/auto index 3adb4be..92ed18f 100755 --- a/auto +++ b/auto @@ -68,7 +68,7 @@ main(){ usage exit 0 } ;; - ( build | dev | test | package | docs | clean | smoke ) { + ( build | dev | test | package | docs | clean | smoke | format ) { shift exec "${lib}/cmd/${cmd}" $@ || exit $? } ;; diff --git a/autolib/cmd/dev b/autolib/cmd/dev index 8025993..2c31dd3 100755 --- a/autolib/cmd/dev +++ b/autolib/cmd/dev @@ -60,7 +60,7 @@ run(){ pushd docker > /dev/null || return $? make || { r=$? - outlib_output_error "Docker Build Failure" + autolib_output_error "Docker Build Failure" return $r } popd > /dev/null diff --git a/autolib/cmd/format b/autolib/cmd/format new file mode 100755 index 0000000..b2e13d8 --- /dev/null +++ b/autolib/cmd/format @@ -0,0 +1,73 @@ +#!/usr/bin/env bash + +######################################################################################################################## +# Meta +######################################################################################################################## + +# Propagate environment variables +if [[ "$AUTO_DEBUG" == "1" ]]; then + set -x + export AUTO_DEBUG=1 +fi + +PROGRAM_NAME=$(basename $0) + +short="Format the project" +read -d '' long < $temp && + sed -i 's/Copyright 2019-2020/Copyright 2019-2020/g' $temp && + mv $temp $file_path + } || { + return_value=$? + autolib_output_error "failed to format project" + exit $return_code + } + done < <(find ${PWD} -regextype posix-extended -type f -regex ".*/prom[[:alnum:]_-]+\.[c|h]" ! -regex '.*CPack.*') || { + return_value=$? + autolib_output_error "failed to find relevant C project files" + exit $return_code + } +} + +[[ $BASH_SOURCE == $0 ]] && main $@ \ No newline at end of file diff --git a/autolib/docker.sh b/autolib/docker.sh index 9834c4b..7f78d83 100644 --- a/autolib/docker.sh +++ b/autolib/docker.sh @@ -11,7 +11,7 @@ FROM __DOCKER_IMAGE__ RUN set -x && \ apt-get update && \ - apt-get install -y apt-utils software-properties-common && \ + apt-get install -y apt-utils software-properties-common clang-format && \ add-apt-repository ppa:ubuntu-toolchain-r/test && \ apt-get update -y && \ apt-get install -y curl tar build-essential git pkg-config gdb valgrind gcc-10 libmicrohttpd-dev doxygen graphviz && \ @@ -43,6 +43,36 @@ FROM __DOCKER_IMAGE__ ENV GCC_VERSION 10.1.0 +RUN set -x && \ + apt-get update && \ + apt-get install -y apt-utils clang-format && \ + apt-get install -y curl tar build-essential git pkg-config gdb valgrind gcc libmicrohttpd-dev doxygen graphviz && \ + curl -sL https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.5-Linux-x86_64.tar.gz | tar xzf - -C /opt && \ + cp /opt/cmake-3.14.5-Linux-x86_64/bin/* /usr/local/bin/ && \ + cp -R /opt/cmake-3.14.5-Linux-x86_64/share/cmake-3.14 /usr/local/share/ && \ + curl -sL https://dl.google.com/go/go1.13.1.linux-amd64.tar.gz 2> /dev/null | tar xzf - -C /usr/local && \ + mkdir -p /gopath/{src,bin} && \ + printf 'export GOPATH=/gopath\nexport PATH=$PATH:/usr/local/go/bin:/gopath/bin\n' > /root/.bash_profile && \ + printf '#!/usr/bin/env bash\nsource /root/.bash_profile\nexec /bin/bash $@\n' > /entrypoint && \ + chmod +x /entrypoint && \ + GOPATH=/gopath /usr/local/go/bin/go get github.com/prometheus/prom2json && \ + GOPATH=/gopath /usr/local/go/bin/go install github.com/prometheus/prom2json/cmd/prom2json && \ + GOPATH=/gopath /usr/local/go/bin/go get github.com/git-chglog/git-chglog && \ + GOPATH=/gopath /usr/local/go/bin/go install github.com/git-chglog/git-chglog/cmd/git-chglog && \ + rm -rf /var/lib/apt/lists/* + +WORKDIR /code +ENTRYPOINT ["/entrypoint"] + +EOF +} + +autolib_debian_jessie_template() { + cat < ${PROJECT_ROOT}/docker/Dockerfile || { r=$? autolib_output_error "failed to generate dockerfile" return $r } } ;; + ( debian:jessie ) { + autolib_debian_jessie_template | sed "s/__DOCKER_IMAGE__/$docker_image/g" > ${PROJECT_ROOT}/docker/Dockerfile || { + r=$? + autolib_output_error "failed to generate dockerfile" + return $r + } + } ;; ( * ) { r=1 autolib_output_error "unsupported DOCKER_IMAGE: $docker_image" diff --git a/example/example b/example/example new file mode 100755 index 0000000000000000000000000000000000000000..37f8c8e70bc2a1e083478244e0133ad6959ca8f2 GIT binary patch literal 20016 zcmeHPdwg6~oj-SGZgMk8C(kwsP3g2yC}1aPX-lCN@|t!6X%h1QT7=6aGf8GUnF;gg zYo%lxs+~_L+X7-m(5jzxs~;cLU0EKY!74@cc zadZw03o=ts>Aeqng_8G9K$#Tkmi6U}OPP#^f)q!(>cgS_wX5sHffeCUB)N0N&UI^7 ztX=JiM?I@}yU9MuZtCbGaYkljC^(;*M>OL9c(mtlY* z&Z`{;D{^p_gXYdbe=CptYkBA&g^gVH*P!va=o|9bDaqr{Re9)_!2Z%4{_oG@&-?Pw z|1pn0l;64hAIl@ZFpvE2^2pos$REw)=lAl^&*h>2AWywd=8?Z65B*FYJ6qv@8LMGk zZZ|Y%uT7j@&C0Uqi(sc5@`|pW8&!}edX1D<^bToX$*UT+!A=D$W=D$^MZi}8Dp)D| z_sUEHTP;meDrv&3>Hg%vwqPP|;(-+O$Cx=7iiA`>bKDzA#uL(6I4}}S#6knC ztGjcv+0xnG?rrJq>^8f-o7#GMySJFF-i=Lt?Y&kX{eeJU+kxPqKN(J-S)qiA_i!RH zN-?K!P}z(J6Q+M45!xQi5j~3-?|^_mh~6MuBcXvfc|i3HzfmV9+1f};txfb84UOnelYsuaX|+u5@4I!+nQUg1#-IH*{EGi<>}SYz_1>xqg)l;~Gn3yJj3qA!710|eB+aV#y1IXu zd?TEf?|ns|l;a#D>wZ)C3ya;{BN_uJkBM-~Lg(WHF2&fCg|6x#);S9uj;62k7P>P{ zMLVTGG}cjLAY!ZM0@2lwgy`#}9U225OzEr9LbpcPXQ8Vx1Sxe{=+<%8%@(?KoN>E_ zZhZs|Tj=yIQ`e}4EdXcg+AY6|1k@FfrUP4p{IwW;6H1j*I49FTIjVFx^Mif;hWHxRk@jO-(oKj)>Ajek`PANY<#_`Jur<9l;<@i#B%D%V`XtByjqnP>CprEc;gy6ROY09F1kSIOzidnW;5J|C=f3gN=el~^59kk} z?Y;x^F5+Or_Yk?6`47UzZ%P-p5@*BXKzs-EuMoKUd}2PjZ4Z^vZACMuN*9lj;o}lQ zKE>tN>?Ls7TfWpe-_!qlo$u-McAxf)?+0%ss$jq?4Hz@026;V7e{91RuvoIb&o{o| z5-R#qFC|KR6B{lEGPME`nHt8=Gx|#4+O0}Y!RfyRvky8*u!hu~FZxo+lL6m^W7%>z z=}URfube#LJ&Q7f7c=E<_H|xPotXOhn=>;h@7eJ?&$5I*;XQk1rEkJ}5-R5gOMms9 z*Gezn{NkXmbkB3p`v&xU2R5JcrM?eRKS6hZ@4%W0p;$|b zj4Pa&dQ2$RLh&HlKrV^)!=e&JMFVNmufSPd! zBS1F*Or0l72+&Cm^(J1K{$7%p8=xzM;wn=7?>`E~j|jywD9#Dc4QZFA#vnd*EqY^W zE0XH9(lUJ`8Jp0r1Na6#at2G6KT8=fIkg&UO^;D;@_zNDzKPB`ftv|V{|I2p&g(oe zwNTXkaH*SpgT$vkhguHa%Cn>gNn4Y;^K5(ShwZ7pQ&9aZsT$<=gnl(tsM)n-VM1Rj z(Q7!@PMm*5@i9t_REvRz-FjZe_V3OfA>vbEG{cwrDm}-tk`Y-|hTu&BPWr|tOMD0V zCI?TjwkPpq=;vBK+u(^tXWJ9LR9DG~#;UfNUmToz9k+y&KLqk{xttTk4x4)eht4=SI#fNq2PW8J@{gEfAjY zK8uI?@41L?VlzEBO4PILO7OpP{9w~fO*gise%#d8gm=fXJwC* z?U&J`*YG|4rhTgVJRI2f%Y=L7Pf8cxP0?rVsXw%*UT;nPs%fU`Mc?>w&3E-rldsUb z|CU>u-rsa<(``-W@q>dNCI9Q=$QiQ7M+Y<(v@tnnat}sh_=__9Va~y)UM%eI4~7|^ zcV+N7B}22{A7l8-tEu=xGd(SHCnK0*x)YcVGWs#o9OjG)DPgHQ5}ug}bMp$_IM+vuvfzO;CUF~+XDVEyG+ zUc8h{kbW!vhGCbIU0tO6e*AgS#(Rm_uo|pw7nHFkD*U^9yGhk{@&K?s=3$hb-52XnqAB9(S5Fl4;J`b>&6Q=yBcGzbxp2@ zCfD+2mm6}BZ+01c-gpn}oPr(MmE_gC*SisTHv;cQ;N1xPwM4)r8miX)@JirUHoQX; z6#c0zoYo@g;^PiLwf?TwwA8wLEtjJ2j&5FBC~@^Jr|(&GsddRZfilJa?OQWZA{~}5 zEzDc_bxs!4+T#n7uhtNg5?5<-HB!&IWrU$3NaG&5)c8fM`KdLmXXPTM zqQ4*=R(_uo>iAA9E>-`95?688;mZ=f zE@6R6z?@#^C#v=CO)V|gxR>|!V|I{quWazF^fatkmE`EkJuBCF8dhH>$?QF_CelUp zg)VQcB{FrgD--fG*cI}ZlnRMIEq?@62>DHALcS(XU(=^u2Ny9kS{g5*T>Ulvaye!* z3Taqt(~K_>uoeE0fTQp*Cl-8}6ZLs8X?N(MNP^i6oo+dsR`3{rgT|t|5hjYkZ$%iS zadbg7RBTJ@4xwDQmk3Yc$9{43J}SSAAIC+!Y%?6+17>KD*Q(0Di*k{@!R-bl%Maq$ z_y_!G^Gp8+pvb;F&HEJL6m0Fng8OCA`52u@4?Ag!r&a4T>Q*f$&*;(~F5V8_JmT37 zwU;cT%B$<{;ArE#7}IJB1@HZsdV=X--v>{|^9m3sp4lBo-%w>dRj_0rWz1xRGGnb- zgRH_T0?H$)8*$kEf5($13tFX&=Q_6=Hq!B2NxUi<&&D*5$8$aL78U%nOiD{UX=1A_ z&{xBbYI$Zn7tAAGI-U#a?&2tqXLX_AA)ZeoPaN!F)Fb2R#>1Q9nVs0%A(A^WRnl5R zr$R1b?O2CeZ1>dO2D^@ODj!%#W!)$+_K{m6e+#KxVBAAeG}X2Lpt_m38M$mcfIIC4 z$8QaqoE2>b;&`2>2N2w7jz1PrLye-#!FIgCk+Pz%p-#t}9H}W-}3Sc9{GENB8-=iEwKHi0!dD-b1zLtsAVPBO0xtjqZjSt$_M&CVrc#n2Yq z19-c$ktCg3)qTK*otKi85{ii<{$^@2h_K}qeZC((q+39Seb}rB=sNcq%zaYtK zt+Wl;US}bBR-+m8HXe7Lruyo%(xZU;omGE`Wggw%=snat46J+;TF1)wBW_xGC1kYnlOWs5L;UwE_;r-O1{tILQB+}+{~nTM<%1}@%dbH_ zjpYl$^_8Cl#aI4qSQsn6AC$2QT2EzK#ft=N6+Kjst>P637`BS%$fB*HoJ`s(!o+h_ zjDQEgcX1dMVN}G*Dt424S;cX}F0S|k6aXF}Vq?V=VPloQB8+LQlHzBez^eAcVu3*o zMBbpdwC+umtM)?9aWA9_7cX}~x#~qQT}!|!Tz1i75DE+%e&uVy;Ya(5F0OtR{P|Zw zOIuXg0d|qy=XO(-5PuKw1;2q6Z4H0emz8q{<4Y+hY7ajESE^ru32lvwy2pO##XZ$Y zjxQme{m{uhHF&sP#k0bG=-i&#uadoWr4MoL*j=?BqPjOPI0Gg7p<{Q|((7C6=JGo5 zi;N5WMCmggmv3jD2E6uyLtO7 z_&K$w?(0(Ir$U0&QoFQkN|wQt{m}V6b=C9{57*rSu$rArYnAOhy9dO&UrGteI=X5% zA*$MK6@=Rl{RT1x#vznT=;w2Af!_fRwutn!#q-pInJ;h=>0#ukw#-#oY_ZCX)V>$So2^rgq&CAlz@<~kqCHAWlH?jwkESL zcpssMR96*>t}`k%yQ{cZ1Y1KF7R|E+bR7o#PD#+IPl-@GYZ&p@w6;ppo3{k1P!F~% zv#+W9ORwT-QszKi*A`Q%pg!0mz4GO#uMT<@yny_y`U>a|byX+4!=x zrv1@1k7>B*w!;7Q$#|?D`@q7Vuzjz7?Mr&O@q}Kw zSHCl?}zh#TA-=bI9TFUi`y}I3AoY1vT=!@-3->d6J{gW@fq&vT$+sE}w?OPK@Lf230 zcH5dty>N?On$$~dS5@lvkL#sdb>pC3al^}c(RX#jcu6l2ndmyA>mS#P>vbn+ERN1vm{V|Y+!hU*!b;UG2~t`=#TG;3=GGjk!Ui$A{p5ciUd|9Xgg^f zOup%G1-dK2cZ#l{?V*t&YlpH~Z;}z(u^0@vm0RMgVwyZKj7gdGSzsm@HZju9)%b8U zmcUm>ivcdkEkLY(AQ}kP2Y32MMj=g2R^LK}Ce_FlM3zBAd?OV%HhxXv3zc}VsGv*) z=nJM94F}BV;2^emGFbEZBY|)*#&>G=^?1$RzV7Bu?5OQDcf>-8pgEeD<$1fivGKIM za}(#s{n#B!+bU;;3FH36v8Qu)5Z=)S(5CkG&YR4hzMd{`M=SQN_VjJ`s_ zBrS5Lt!w*QZoWS`X!iT#!L*yL-sV2IfnMGgjA7R({EY?u0q#%Mhg`ZncT>yh{xY}w z!%2&ozNU7wr?;u)hP36bwl1%^5$){p_4T%P-qgY5-c{M5*&fSAlDkcPy`5%TN3XZL z17>@D-QK3wwB4S*t}e8_$82rt^_m@>W=ne~sx`yWfo*9aZx{CW<~0GOcI^4}c9=a- z_4dB)mSA%rNxdIVj$l*lVAwxI`)f!2fz`aijqObc;b=6TuD++Io%v%!+tUQ$kIacU zdVxoJV_Um7Ez;Z4Wo~Th>Fq@C&Juas%`R^@b}V;vV8?P>r-j?zla}N)P^AND5`~f1 zBYKyaJoTw^l^2;|YTtseboAY9c6PLH;ff-4dBT{^bA1gi&9+6#3PQTy6D zHmRG5`i(z#xK;U*##ZofFoJyI@q)c}kA|p4I^IJOo+6Da` zTy_lf)?omUec_##K2K%k*)cFkr8zw$)p!B^<5>CUdYt;r?20&r zfqV94#|ad5{>;j=<3veA_6H;g*jZ)z`&OoWRr)h;yj^?Wq-FpQlZ}2=No2#{3@04ROkfKL6WzNo2wyfBaaD$waXWVS!o=8@mZ=`NQ2J#!$B z{CRkr>%8UmJo5A@i~2F!pO58{e>M;O1<)xD%8rV|c}Z`OaaME(5-(Rg=Yvjm8nfi- zO90VpvglXlv2#7AyYO8^bRR8}({(HNf9|-VGmjlM5KF`p$-zM^$;=)JH4`}7Nrysd zRuhPtL*Zz@KWqkY(lc)QlRL3Nm}b$5V8GLmTY{g$H2txde;1|#iP$bSh-08ZGmsn^ z*##8~#%I%+qI?-pOuXetbap(gkzF9QRw^|N)$^()E@uWC)nl(R0 z3s6VKfm%9=+1RL#OVS}pI;WXQu`FBAaaUTZ5K9kp&SU1)qhqRn>X>hO5rYr=v04@} zX)Z@~3B8tC`WaVDGGqY#LU6SKM5W>LaswMU)o=F3as>~W?%^TcjCu%8rUX*8T*9^UO96g@*xpb1)o@bEL^o>-KhZuSI+<@0Gc z03!+$s^ak>G*lTi__3x8pXhM32WO+12T#ZmJorEh_9urR>5mNIaVpVJWH74A{{H@0 zaJ$0j6uT-TO5&;h=l{}7N5h|dO{C}9YQ9~URRzgfuZw`tohdb(3+e z1ZLG&^L7O<&XAs~-wHmCOhi@vhh;&*MyZdFW&Bd_VTrO16lhAV^k0w#1=Z#lq53k_kilG)2qSr|~w4kbiWk zeX|N;#*}f9uhuIC#Hz2>M--&}3D!&QO2F7pTn_+P_0>9xg34cIL*WWOlBKWaWeR>p zHB1^%^(uRx&eB)=gcVf#WtDt(`#&r7RsX5=n>1945-PtH`O8`QYMn2;_@B+ZyxHcWM+(o_9-7&6pErLWej+>1#Y=ZpC7?2pn{@D;GE`dGLT z!V;)@1aa1Xg`Y!#Y^nOyJfzGmBpL-s|EhWw;kPJI{SAsBq0(3D3yMv$bSe0jrOX-f zXT4h#4qAyQD?LS~9ktms;(gaGB!XEEXUo$1Nj8l%8!i+28&qHfI!E@>Jo+Q=5eoOc zjsBHVKRbRi^+G?U5+|#Eu+ln60{Cwy|PgDe`9v1?*IS* literal 0 HcmV?d00001 diff --git a/prom/include/prom_alloc.h b/prom/include/prom_alloc.h index 0f00d0d..0f11c81 100644 --- a/prom/include/prom_alloc.h +++ b/prom/include/prom_alloc.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -45,4 +45,4 @@ limitations under the License. */ #define prom_free free -#endif // PROM_ALLOC_H \ No newline at end of file +#endif // PROM_ALLOC_H diff --git a/prom/include/prom_collector.h b/prom/include/prom_collector.h index 5a1e2ba..1475f13 100644 --- a/prom/include/prom_collector.h +++ b/prom/include/prom_collector.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -40,14 +40,14 @@ typedef struct prom_collector prom_collector_t; * @param self The target prom_collector_t* * @return The prom_map_t* containing the collected metrics */ -typedef prom_map_t* prom_collect_fn(prom_collector_t* self); +typedef prom_map_t *prom_collect_fn(prom_collector_t *self); /** * @brief Create a collector * @param name The name of the collector. The name MUST NOT be default or process. * @return The constructed prom_collector_t* */ -prom_collector_t* prom_collector_new(const char *name); +prom_collector_t *prom_collector_new(const char *name); /** *@brief Construct a prom_collector_t* which includes the default process metrics @@ -57,7 +57,7 @@ prom_collector_t* prom_collector_new(const char *name); * by the host environment. Otherwise, pass a string to said path. * @return The constructed prom_collector_t* */ -prom_collector_t* prom_collector_process_new(const char *limits_path, const char *stat_path); +prom_collector_t *prom_collector_process_new(const char *limits_path, const char *stat_path); /** * @brief Destroy a collector. You MUST set self to NULL after destruction. @@ -97,4 +97,4 @@ int prom_collector_add_metric(prom_collector_t *self, prom_metric_t *metric); */ int prom_collector_set_collect_fn(prom_collector_t *self, prom_collect_fn *fn); -#endif // PROM_COLLECTOR_H \ No newline at end of file +#endif // PROM_COLLECTOR_H diff --git a/prom/include/prom_collector_registry.h b/prom/include/prom_collector_registry.h index 974aa24..abb74ab 100644 --- a/prom/include/prom_collector_registry.h +++ b/prom/include/prom_collector_registry.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -47,7 +47,7 @@ int prom_collector_registry_default_init(void); * @param name The name of the collector registry. It MUST NOT be default. * @return The constructed prom_collector_registry_t* */ -prom_collector_registry_t* prom_collector_registry_new(const char *name); +prom_collector_registry_t *prom_collector_registry_new(const char *name); /** * @brief Destroy a collector registry. You MUST set self to NULL after destruction. @@ -74,7 +74,7 @@ int prom_collector_registry_enable_process_metrics(prom_collector_registry_t *se * @param metric The metric to register on PROM_DEFAULT_COLLECTOR_REGISTRY* * @return The registered prom_metric_t* */ -prom_metric_t* prom_collector_registry_must_register_metric(prom_metric_t *metric); +prom_metric_t *prom_collector_registry_must_register_metric(prom_metric_t *metric); /** * @brief Registers a metric with the default collector on PROM_DEFAULT_COLLECTOR_REGISTRY. Returns an non-zero integer @@ -104,7 +104,7 @@ int prom_collector_registry_register_collector(prom_collector_registry_t *self, * @param self The target prom_collector_registry_t* * @return The string int he default metric exposition format. */ -const char* prom_collector_registry_bridge(prom_collector_registry_t *self); +const char *prom_collector_registry_bridge(prom_collector_registry_t *self); /** *@brief Validates that the given metric name complies with the specification: @@ -117,7 +117,6 @@ const char* prom_collector_registry_bridge(prom_collector_registry_t *self); * @param metric_name The metric name to validate * @return A non-zero integer value upon failure */ -int prom_collector_registry_validate_metric_name(prom_collector_registry_t *self, - const char *metric_name); +int prom_collector_registry_validate_metric_name(prom_collector_registry_t *self, const char *metric_name); -#endif // PROM_H +#endif // PROM_H diff --git a/prom/include/prom_counter.h b/prom/include/prom_counter.h index cb3ca32..cd3d20a 100644 --- a/prom/include/prom_counter.h +++ b/prom/include/prom_counter.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ See the License for the specific language governing permissions and limitations under the License. */ - #ifndef PROM_COUNTER_H #define PROM_COUNTER_H @@ -54,10 +53,7 @@ typedef prom_metric_t prom_counter_t; * // An example without labels * prom_counter_new("foo", "foo is a counter without labels", 0, NULL); */ -prom_counter_t* prom_counter_new(const char *name, - const char *help, - size_t label_key_count, - const char **label_keys); +prom_counter_t *prom_counter_new(const char *name, const char *help, size_t label_key_count, const char **label_keys); /** * @brief Destroys a prom_counter_t*. You must set self to NULL after destruction. A non-zero integer value will be @@ -67,7 +63,6 @@ prom_counter_t* prom_counter_new(const char *name, */ int prom_counter_destroy(prom_counter_t *self); - /** * @brief Increment the prom_counter_t by 1. A non-zero integer value will be returned on failure. * @param self The target prom_counter_t* @@ -86,7 +81,6 @@ int prom_counter_destroy(prom_counter_t *self); */ int prom_counter_inc(prom_counter_t *self, const char **label_values); - /** * @brief Add the value to the prom_counter_t*. A non-zero integer value will be returned on failure. * @param self The target prom_counter_t* @@ -106,4 +100,4 @@ int prom_counter_inc(prom_counter_t *self, const char **label_values); */ int prom_counter_add(prom_counter_t *self, double r_value, const char **label_values); -#endif // PROM_COUNTER_H \ No newline at end of file +#endif // PROM_COUNTER_H diff --git a/prom/include/prom_gauge.h b/prom/include/prom_gauge.h index e944b72..4b3f55e 100644 --- a/prom/include/prom_gauge.h +++ b/prom/include/prom_gauge.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -51,10 +51,7 @@ typedef prom_metric_t prom_gauge_t; * // An example without labels * prom_gauge_new("foo", "foo is a gauge without labels", 0, NULL); */ -prom_gauge_t* prom_gauge_new(const char *name, - const char *help, - size_t label_key_count, - const char **label_keys); +prom_gauge_t *prom_gauge_new(const char *name, const char *help, size_t label_key_count, const char **label_keys); /** * @brief Destroys a prom_gauge_t*. You must set self to NULL after destruction. A non-zero integer value will be @@ -64,7 +61,6 @@ prom_gauge_t* prom_gauge_new(const char *name, */ int prom_gauge_destroy(prom_gauge_t *self); - /** * @brief Increment the prom_gauge_t* by 1. * @param self The target prom_gauger_t* @@ -82,7 +78,6 @@ int prom_gauge_destroy(prom_gauge_t *self); */ int prom_gauge_inc(prom_gauge_t *self, const char **label_values); - /** * @brief Decrement the prom_gauge_t* by 1. * @param self The target prom_gauger_t* @@ -100,7 +95,6 @@ int prom_gauge_inc(prom_gauge_t *self, const char **label_values); */ int prom_gauge_dec(prom_gauge_t *self, const char **label_values); - /** * @brief Add the value to the prom_gauge_t*. * @param self The target prom_gauge_t* @@ -120,7 +114,6 @@ int prom_gauge_dec(prom_gauge_t *self, const char **label_values); */ int prom_gauge_add(prom_gauge_t *self, double r_value, const char **label_values); - /** * @brief Subtract the value to the prom_gauge. A non-zero integer value will be returned on failure. * @param self The target prom_gauge_t* @@ -140,7 +133,6 @@ int prom_gauge_add(prom_gauge_t *self, double r_value, const char **label_values */ int prom_gauge_sub(prom_gauge_t *self, double r_value, const char **label_values); - /** * @brief Set the value for the prom_gauge_t* * @param self The target prom_gauge_t* diff --git a/prom/include/prom_histogram.h b/prom/include/prom_histogram.h index 74962b3..e887ccb 100644 --- a/prom/include/prom_histogram.h +++ b/prom/include/prom_histogram.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -24,8 +24,8 @@ limitations under the License. #include -#include "prom_metric.h" #include "prom_histogram_buckets.h" +#include "prom_metric.h" /** * @brief A prometheus histogram. @@ -57,11 +57,8 @@ typedef prom_metric_t prom_histogram_t; * prom_histogram_buckets_t* buckets = prom_histogram_buckets_linear(5.0, 5.0, 10); * prom_histogram_new("foo", "foo is a counter without labels", buckets, 0, NULL); */ -prom_histogram_t* prom_histogram_new(const char *name, - const char *help, - prom_histogram_buckets_t *buckets, - size_t label_key_count, - const char **label_keys); +prom_histogram_t *prom_histogram_new(const char *name, const char *help, prom_histogram_buckets_t *buckets, + size_t label_key_count, const char **label_keys); /** * @brief Destroy a prom_histogram_t*. self MUSTS be set to NULL after destruction. Returns a non-zero integer value @@ -70,7 +67,6 @@ prom_histogram_t* prom_histogram_new(const char *name, */ int prom_histogram_destroy(prom_histogram_t *self); - /** * @brief Observe the prom_histogram_t given the value and labells * @param self The target prom_histogram_t* diff --git a/prom/include/prom_histogram_buckets.h b/prom/include/prom_histogram_buckets.h index 24afe22..d3112d8 100644 --- a/prom/include/prom_histogram_buckets.h +++ b/prom/include/prom_histogram_buckets.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -36,7 +36,7 @@ typedef struct prom_histogram_buckets { * passed as count. * @return The constructed prom_histogram_buckets_t* */ -prom_histogram_buckets_t* prom_histogram_buckets_new(size_t count, double bucket, ...); +prom_histogram_buckets_t *prom_histogram_buckets_new(size_t count, double bucket, ...); /** * @brief the default histogram buckets: .005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10 @@ -50,7 +50,7 @@ extern prom_histogram_buckets_t *prom_histogram_default_buckets; * @param count The total number of buckets. The final +Inf bucket is not counted and not included. * @return The constructed prom_histogram_buckets_t* */ -prom_histogram_buckets_t* prom_histogram_buckets_linear(double start, double width, size_t count); +prom_histogram_buckets_t *prom_histogram_buckets_linear(double start, double width, size_t count); /** * @brief Construct an exponentially sized prom_histogram_buckets_t* @@ -61,8 +61,7 @@ prom_histogram_buckets_t* prom_histogram_buckets_linear(double start, double wid * greater than or equal to 1 * @return The constructed prom_histogram_buckets_t* */ -prom_histogram_buckets_t* prom_histogram_buckets_exponential(double start, double factor, size_t count); - +prom_histogram_buckets_t *prom_histogram_buckets_exponential(double start, double factor, size_t count); /** * @brief Destroy a prom_histogram_buckets_t*. Self MUST be set to NULL after destruction. Returns a non-zero integer @@ -79,4 +78,4 @@ int prom_histogram_buckets_destroy(prom_histogram_buckets_t *self); */ size_t prom_histogram_buckets_count(prom_histogram_buckets_t *self); -#endif // PROM_HISTOGRAM_BUCKETS_H +#endif // PROM_HISTOGRAM_BUCKETS_H diff --git a/prom/include/prom_linked_list.h b/prom/include/prom_linked_list.h index 35a0701..7381622 100644 --- a/prom/include/prom_linked_list.h +++ b/prom/include/prom_linked_list.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ See the License for the specific language governing permissions and limitations under the License. */ - #ifndef PROM_LIST_H #define PROM_LIST_H @@ -22,9 +21,8 @@ limitations under the License. struct prom_linked_list; /** -* @brief Provides a generic linked list -*/ + * @brief Provides a generic linked list + */ typedef struct prom_linked_list prom_linked_list_t; - #endif // PROM_LIST_H diff --git a/prom/include/prom_map.h b/prom/include/prom_map.h index 73930b4..aafbaaf 100644 --- a/prom/include/prom_map.h +++ b/prom/include/prom_map.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -23,4 +23,4 @@ typedef struct prom_map prom_map_t; struct prom_map_node; typedef struct prom_map_node prom_map_node_t; -#endif // PROM_MAP_H +#endif // PROM_MAP_H diff --git a/prom/include/prom_metric.h b/prom/include/prom_metric.h index ee2874a..0d8a549 100644 --- a/prom/include/prom_metric.h +++ b/prom/include/prom_metric.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -46,7 +46,7 @@ typedef struct prom_metric prom_metric_t; * necessary, pass NULL. Otherwise, It may be convenient to pass this value as a literal. * @return A prom_metric_sample_t* */ -prom_metric_sample_t* prom_metric_sample_from_labels(prom_metric_t *self, const char **label_values); +prom_metric_sample_t *prom_metric_sample_from_labels(prom_metric_t *self, const char **label_values); /** * @brief Returns a prom_metric_sample_histogram_t*. The order of label_values is significant. @@ -61,7 +61,7 @@ prom_metric_sample_t* prom_metric_sample_from_labels(prom_metric_t *self, const * necessary, pass NULL. Otherwise, It may be convenient to pass this value as a literal. * @return prom_metric_sample_histogram_t* */ -prom_metric_sample_histogram_t* prom_metric_sample_histogram_from_labels(prom_metric_t *self, +prom_metric_sample_histogram_t *prom_metric_sample_histogram_from_labels(prom_metric_t *self, const char **label_values); #endif // PROM_METRIC_H diff --git a/prom/include/prom_metric_sample.h b/prom/include/prom_metric_sample.h index 21c68d2..72757b9 100644 --- a/prom/include/prom_metric_sample.h +++ b/prom/include/prom_metric_sample.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/prom/include/prom_metric_sample_histogram.h b/prom/include/prom_metric_sample_histogram.h index 535e69b..5dedffd 100644 --- a/prom/include/prom_metric_sample_histogram.h +++ b/prom/include/prom_metric_sample_histogram.h @@ -1,5 +1,5 @@ /* -Copyright 2019 DigitalOcean Inc. +Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -36,4 +36,4 @@ typedef struct prom_metric_sample_histogram prom_metric_sample_histogram_t; */ int prom_metric_sample_histogram_observe(prom_metric_sample_histogram_t *self, double value); -#endif // PROM_METRIC_SAMPLE_HISOTGRAM_H \ No newline at end of file +#endif // PROM_METRIC_SAMPLE_HISOTGRAM_H diff --git a/prom/src/prom_assert.h b/prom/src/prom_assert.h index 6ca2e13..3848fd9 100644 --- a/prom/src/prom_assert.h +++ b/prom/src/prom_assert.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,9 +20,9 @@ #define PROM_ASSERT_H #ifdef PROM_ASSERT_ENABLE - #define PROM_ASSERT(i) assert(i); +#define PROM_ASSERT(i) assert(i); #else - #define PROM_ASSERT(i) -#endif // PROM_TEST +#define PROM_ASSERT(i) +#endif // PROM_TEST -#endif // PROM_ASSERT_H \ No newline at end of file +#endif // PROM_ASSERT_H diff --git a/prom/src/prom_collector.c b/prom/src/prom_collector.c index 8e8e5ff..c25349c 100644 --- a/prom/src/prom_collector.c +++ b/prom/src/prom_collector.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -31,18 +31,15 @@ #include "prom_process_fds_t.h" #include "prom_process_limits_i.h" #include "prom_process_limits_t.h" -#include "prom_process_stat_t.h" #include "prom_process_stat_i.h" +#include "prom_process_stat_t.h" #include "prom_string_builder_i.h" +prom_map_t *prom_collector_default_collect(prom_collector_t *self) { return self->metrics; } -prom_map_t* prom_collector_default_collect(prom_collector_t *self) { - return self->metrics; -} - -prom_collector_t* prom_collector_new(const char *name) { +prom_collector_t *prom_collector_new(const char *name) { int r = 0; - prom_collector_t *self = (prom_collector_t*) prom_malloc(sizeof(prom_collector_t)); + prom_collector_t *self = (prom_collector_t *)prom_malloc(sizeof(prom_collector_t)); self->name = prom_strdup(name); self->metrics = prom_map_new(); if (self->metrics == NULL) { @@ -80,7 +77,7 @@ int prom_collector_destroy(prom_collector_t *self) { if (r) ret = r; self->string_builder = NULL; - prom_free((char *) self->name); + prom_free((char *)self->name); self->name = NULL; prom_free(self); self = NULL; @@ -90,15 +87,15 @@ int prom_collector_destroy(prom_collector_t *self) { int prom_collector_destroy_generic(void *gen) { int r = 0; - prom_collector_t *self = (prom_collector_t *) gen; + prom_collector_t *self = (prom_collector_t *)gen; r = prom_collector_destroy(self); self = NULL; return r; - } +} void prom_collector_free_generic(void *gen) { - prom_collector_t *self = (prom_collector_t *) gen; - prom_collector_destroy(self); + prom_collector_t *self = (prom_collector_t *)gen; + prom_collector_destroy(self); } int prom_collector_set_collect_fn(prom_collector_t *self, prom_collect_fn *fn) { @@ -111,22 +108,19 @@ int prom_collector_set_collect_fn(prom_collector_t *self, prom_collect_fn *fn) { int prom_collector_add_metric(prom_collector_t *self, prom_metric_t *metric) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; - if (prom_map_get(self->metrics, metric->name ) != NULL) { + if (prom_map_get(self->metrics, metric->name) != NULL) { PROM_LOG("metric already found in collector"); return 1; } return prom_map_set(self->metrics, metric->name, metric); } - - - //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Process Collector -prom_map_t* prom_collector_process_collect(prom_collector_t *self); +prom_map_t *prom_collector_process_collect(prom_collector_t *self); -prom_collector_t* prom_collector_process_new(const char *limits_path, const char *stat_path) { +prom_collector_t *prom_collector_process_new(const char *limits_path, const char *stat_path) { prom_collector_t *self = prom_collector_new("process"); PROM_ASSERT(self != NULL); if (self == NULL) return NULL; @@ -167,7 +161,7 @@ prom_collector_t* prom_collector_process_new(const char *limits_path, const char return self; } -prom_map_t* prom_collector_process_collect(prom_collector_t *self) { +prom_map_t *prom_collector_process_collect(prom_collector_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return NULL; @@ -190,7 +184,7 @@ prom_map_t* prom_collector_process_collect(prom_collector_t *self) { } // Retrieve the *prom_process_limits_row_t for Max open files - prom_process_limits_row_t *max_fds = (prom_process_limits_row_t *) prom_map_get(limits_map, "Max open files"); + prom_process_limits_row_t *max_fds = (prom_process_limits_row_t *)prom_map_get(limits_map, "Max open files"); if (max_fds == NULL) { prom_process_limits_file_destroy(limits_f); prom_map_destroy(limits_map); @@ -198,9 +192,8 @@ prom_map_t* prom_collector_process_collect(prom_collector_t *self) { } // Retrieve the *prom_process_limits_row_t for Max address space - prom_process_limits_row_t *virtual_memory_max_bytes = (prom_process_limits_row_t *) prom_map_get( - limits_map, "Max address space" - ); + prom_process_limits_row_t *virtual_memory_max_bytes = + (prom_process_limits_row_t *)prom_map_get(limits_map, "Max address space"); if (virtual_memory_max_bytes == NULL) { prom_process_limits_file_destroy(limits_f); prom_map_destroy(limits_map); @@ -270,6 +263,3 @@ prom_map_t* prom_collector_process_collect(prom_collector_t *self) { return self->metrics; } - - - diff --git a/prom/src/prom_collector_registry.c b/prom/src/prom_collector_registry.c index aa69489..53c1a6d 100644 --- a/prom/src/prom_collector_registry.c +++ b/prom/src/prom_collector_registry.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #include #include #include @@ -26,8 +25,8 @@ // Private #include "prom_assert.h" -#include "prom_collector_t.h" #include "prom_collector_registry_t.h" +#include "prom_collector_t.h" #include "prom_errors.h" #include "prom_log.h" #include "prom_map_i.h" @@ -39,11 +38,10 @@ prom_collector_registry_t *PROM_COLLECTOR_REGISTRY_DEFAULT; -prom_collector_registry_t* prom_collector_registry_new(const char *name) -{ +prom_collector_registry_t *prom_collector_registry_new(const char *name) { int r = 0; - prom_collector_registry_t* self = (prom_collector_registry_t*) prom_malloc(sizeof(prom_collector_registry_t)); + prom_collector_registry_t *self = (prom_collector_registry_t *)prom_malloc(sizeof(prom_collector_registry_t)); self->disable_process_metrics = false; @@ -54,7 +52,7 @@ prom_collector_registry_t* prom_collector_registry_new(const char *name) self->metric_formatter = prom_metric_formatter_new(); self->string_builder = prom_string_builder_new(); - self->lock = (pthread_rwlock_t*) prom_malloc(sizeof(pthread_rwlock_t)); + self->lock = (pthread_rwlock_t *)prom_malloc(sizeof(pthread_rwlock_t)); r = pthread_rwlock_init(self->lock, NULL); if (r) { PROM_LOG("failed to initialize rwlock"); @@ -74,11 +72,9 @@ int prom_collector_registry_enable_process_metrics(prom_collector_registry_t *se return 1; } - int prom_collector_registry_enable_custom_process_metrics(prom_collector_registry_t *self, const char *process_limits_path, - const char *process_stats_path) -{ + const char *process_stats_path) { PROM_ASSERT(self != NULL); if (self == NULL) { PROM_LOG("prom_collector_registry_t is NULL"); @@ -92,7 +88,6 @@ int prom_collector_registry_enable_custom_process_metrics(prom_collector_registr return 1; } - int prom_collector_registry_default_init(void) { if (PROM_COLLECTOR_REGISTRY_DEFAULT != NULL) return 0; @@ -129,7 +124,7 @@ int prom_collector_registry_destroy(prom_collector_registry_t *self) { self->lock = NULL; if (r) ret = r; - prom_free((char *) self->name); + prom_free((char *)self->name); self->name = NULL; prom_free(self); @@ -141,9 +136,8 @@ int prom_collector_registry_destroy(prom_collector_registry_t *self) { int prom_collector_registry_register_metric(prom_metric_t *metric) { PROM_ASSERT(metric != NULL); - prom_collector_t *default_collector = (prom_collector_t *) prom_map_get( - PROM_COLLECTOR_REGISTRY_DEFAULT->collectors, "default" - ); + prom_collector_t *default_collector = + (prom_collector_t *)prom_map_get(PROM_COLLECTOR_REGISTRY_DEFAULT->collectors, "default"); if (default_collector == NULL) { return 1; @@ -152,7 +146,7 @@ int prom_collector_registry_register_metric(prom_metric_t *metric) { return prom_collector_add_metric(default_collector, metric); } -prom_metric_t* prom_collector_registry_must_register_metric(prom_metric_t *metric) { +prom_metric_t *prom_collector_registry_must_register_metric(prom_metric_t *metric) { int err = prom_collector_registry_register_metric(metric); if (err != 0) { exit(err); @@ -171,7 +165,7 @@ int prom_collector_registry_register_collector(prom_collector_registry_t *self, PROM_LOG(PROM_PTHREAD_RWLOCK_LOCK_ERROR); return 1; } - if (prom_map_get(self->collectors, collector->name) != NULL){ + if (prom_map_get(self->collectors, collector->name) != NULL) { PROM_LOG("the given prom_collector_t* is already registered"); int rr = pthread_rwlock_unlock(self->lock); if (rr) { @@ -203,14 +197,14 @@ int prom_collector_registry_validate_metric_name(prom_collector_registry_t *self regex_t r; int ret = 0; ret = regcomp(&r, "^[a-zA-Z_:][a-zA-Z0-9_:]*$", REG_EXTENDED); - if (ret){ + if (ret) { PROM_LOG(PROM_REGEX_REGCOMP_ERROR); regfree(&r); return ret; } ret = regexec(&r, metric_name, 0, NULL, 0); - if (ret){ + if (ret) { PROM_LOG(PROM_REGEX_REGEXEC_ERROR); regfree(&r); return ret; @@ -219,9 +213,8 @@ int prom_collector_registry_validate_metric_name(prom_collector_registry_t *self return 0; } -const char* prom_collector_registry_bridge(prom_collector_registry_t *self) { +const char *prom_collector_registry_bridge(prom_collector_registry_t *self) { prom_metric_formatter_clear(self->metric_formatter); prom_metric_formatter_load_metrics(self->metric_formatter, self->collectors); - return (const char*) prom_metric_formatter_dump(self->metric_formatter); + return (const char *)prom_metric_formatter_dump(self->metric_formatter); } - diff --git a/prom/src/prom_collector_registry_i.h b/prom/src/prom_collector_registry_i.h index d1eb1ef..3cd35ce 100644 --- a/prom/src/prom_collector_registry_i.h +++ b/prom/src/prom_collector_registry_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,4 +23,4 @@ int prom_collector_registry_enable_custom_process_metrics(prom_collector_registr const char *process_limits_path, const char *process_stats_path); -#endif // PROM_COLLECTOR_REGISTRY_I_INCLUDED \ No newline at end of file +#endif // PROM_COLLECTOR_REGISTRY_I_INCLUDED diff --git a/prom/src/prom_collector_registry_t.h b/prom/src/prom_collector_registry_t.h index c7d876e..4bca14d 100644 --- a/prom/src/prom_collector_registry_t.h +++ b/prom/src/prom_collector_registry_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,14 +28,13 @@ #include "prom_metric_formatter_t.h" #include "prom_string_builder_t.h" - struct prom_collector_registry { const char *name; - bool disable_process_metrics; /**< Disables the collection of process metrics */ - prom_map_t *collectors; /**< Map of collectors keyed by name */ - prom_string_builder_t *string_builder; /**< Enables string building */ - prom_metric_formatter_t *metric_formatter; /**< metric formatter for metric exposition on bridge call */ - pthread_rwlock_t *lock; /**< mutex for safety against concurrent registration */ + bool disable_process_metrics; /**< Disables the collection of process metrics */ + prom_map_t *collectors; /**< Map of collectors keyed by name */ + prom_string_builder_t *string_builder; /**< Enables string building */ + prom_metric_formatter_t *metric_formatter; /**< metric formatter for metric exposition on bridge call */ + pthread_rwlock_t *lock; /**< mutex for safety against concurrent registration */ }; -#endif // PROM_REGISTRY_T_H +#endif // PROM_REGISTRY_T_H diff --git a/prom/src/prom_collector_t.h b/prom/src/prom_collector_t.h index 37cc649..db9aab6 100644 --- a/prom/src/prom_collector_t.h +++ b/prom/src/prom_collector_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #ifndef PROM_COLLECTOR_T_H #define PROM_COLLECTOR_T_H @@ -31,4 +30,4 @@ struct prom_collector { const char *proc_stat_file_path; }; -#endif // PROM_COLLECTOR_T_H \ No newline at end of file +#endif // PROM_COLLECTOR_T_H diff --git a/prom/src/prom_counter.c b/prom/src/prom_counter.c index c3d45c1..01dc438 100644 --- a/prom/src/prom_counter.c +++ b/prom/src/prom_counter.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,25 +15,21 @@ */ // Public -#include "prom_alloc.h" #include "prom_counter.h" +#include "prom_alloc.h" + // Private #include "prom_assert.h" #include "prom_errors.h" #include "prom_log.h" #include "prom_metric_i.h" -#include "prom_metric_t.h" #include "prom_metric_sample_i.h" #include "prom_metric_sample_t.h" +#include "prom_metric_t.h" - -prom_counter_t* prom_counter_new(const char *name, - const char *help, - size_t label_key_count, - const char **label_keys) -{ - return (prom_counter_t*) prom_metric_new(PROM_COUNTER, name, help, label_key_count, label_keys); +prom_counter_t *prom_counter_new(const char *name, const char *help, size_t label_key_count, const char **label_keys) { + return (prom_counter_t *)prom_metric_new(PROM_COUNTER, name, help, label_key_count, label_keys); } int prom_counter_destroy(prom_counter_t *self) { @@ -67,4 +63,4 @@ int prom_counter_add(prom_counter_t *self, double r_value, const char **label_va prom_metric_sample_t *sample = prom_metric_sample_from_labels(self, label_values); if (sample == NULL) return 1; return prom_metric_sample_add(sample, r_value); -} \ No newline at end of file +} diff --git a/prom/src/prom_errors.h b/prom/src/prom_errors.h index 2bb7c11..006a184 100644 --- a/prom/src/prom_errors.h +++ b/prom/src/prom_errors.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/prom/src/prom_gauge.c b/prom/src/prom_gauge.c index 9235e58..d9fe845 100644 --- a/prom/src/prom_gauge.c +++ b/prom/src/prom_gauge.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,27 +14,22 @@ * limitations under the License. */ - // Public -#include "prom_alloc.h" #include "prom_gauge.h" +#include "prom_alloc.h" + // Private #include "prom_assert.h" #include "prom_errors.h" #include "prom_log.h" #include "prom_metric_i.h" -#include "prom_metric_t.h" #include "prom_metric_sample_i.h" #include "prom_metric_sample_t.h" +#include "prom_metric_t.h" - -prom_gauge_t* prom_gauge_new(const char *name, - const char *help, - size_t label_key_count, - const char **label_keys) -{ - return (prom_gauge_t*) prom_metric_new(PROM_GAUGE, name, help, label_key_count, label_keys); +prom_gauge_t *prom_gauge_new(const char *name, const char *help, size_t label_key_count, const char **label_keys) { + return (prom_gauge_t *)prom_metric_new(PROM_GAUGE, name, help, label_key_count, label_keys); } int prom_gauge_destroy(prom_gauge_t *self) { diff --git a/prom/src/prom_histogram.c b/prom/src/prom_histogram.c index 8744738..e6c085e 100644 --- a/prom/src/prom_histogram.c +++ b/prom/src/prom_histogram.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,10 +14,10 @@ * limitations under the License. */ - // Public -#include "prom_alloc.h" #include "prom_histogram.h" + +#include "prom_alloc.h" #include "prom_histogram_buckets.h" // Private @@ -26,19 +26,13 @@ #include "prom_log.h" #include "prom_map_i.h" #include "prom_metric_i.h" -#include "prom_metric_t.h" #include "prom_metric_sample_histogram_i.h" #include "prom_metric_sample_histogram_t.h" +#include "prom_metric_t.h" - - -prom_histogram_t* prom_histogram_new(const char *name, - const char *help, - prom_histogram_buckets_t *buckets, - size_t label_key_count, - const char **label_keys) -{ - prom_histogram_t *self = (prom_histogram_t*) prom_metric_new(PROM_HISTOGRAM, name, help, label_key_count, label_keys); +prom_histogram_t *prom_histogram_new(const char *name, const char *help, prom_histogram_buckets_t *buckets, + size_t label_key_count, const char **label_keys) { + prom_histogram_t *self = (prom_histogram_t *)prom_metric_new(PROM_HISTOGRAM, name, help, label_key_count, label_keys); if (buckets == NULL) { self->buckets = prom_histogram_default_buckets; } else { @@ -47,7 +41,7 @@ prom_histogram_t* prom_histogram_new(const char *name, if (i == 0) { continue; } - if (buckets->upper_bounds[i-1] > buckets->upper_bounds[i]) { + if (buckets->upper_bounds[i - 1] > buckets->upper_bounds[i]) { return NULL; } } diff --git a/prom/src/prom_histogram_buckets.c b/prom/src/prom_histogram_buckets.c index 8606767..c92de70 100644 --- a/prom/src/prom_histogram_buckets.c +++ b/prom/src/prom_histogram_buckets.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,10 +27,10 @@ prom_histogram_buckets_t *prom_histogram_default_buckets; -prom_histogram_buckets_t* prom_histogram_buckets_new(size_t count, double bucket, ...) { - prom_histogram_buckets_t *self = (prom_histogram_buckets_t*) prom_malloc(sizeof(prom_histogram_buckets_t)); +prom_histogram_buckets_t *prom_histogram_buckets_new(size_t count, double bucket, ...) { + prom_histogram_buckets_t *self = (prom_histogram_buckets_t *)prom_malloc(sizeof(prom_histogram_buckets_t)); self->count = count; - double *upper_bounds = (double*) prom_malloc(sizeof(double)*count); + double *upper_bounds = (double *)prom_malloc(sizeof(double) * count); upper_bounds[0] = bucket; if (count == 1) { self->upper_bounds = upper_bounds; @@ -46,23 +46,22 @@ prom_histogram_buckets_t* prom_histogram_buckets_new(size_t count, double bucket return self; } - -prom_histogram_buckets_t* prom_histogram_buckets_linear(double start, double width, size_t count) { +prom_histogram_buckets_t *prom_histogram_buckets_linear(double start, double width, size_t count) { if (count <= 1) return NULL; - prom_histogram_buckets_t *self = (prom_histogram_buckets_t*) prom_malloc(sizeof(prom_histogram_buckets_t)); + prom_histogram_buckets_t *self = (prom_histogram_buckets_t *)prom_malloc(sizeof(prom_histogram_buckets_t)); - double *upper_bounds = (double*) prom_malloc(sizeof(double) * count); + double *upper_bounds = (double *)prom_malloc(sizeof(double) * count); upper_bounds[0] = start; for (size_t i = 1; i < count; i++) { - upper_bounds[i] = upper_bounds[i-1] + width; + upper_bounds[i] = upper_bounds[i - 1] + width; } self->upper_bounds = upper_bounds; self->count = count; return self; } -prom_histogram_buckets_t* prom_histogram_buckets_exponential(double start, double factor, size_t count) { +prom_histogram_buckets_t *prom_histogram_buckets_exponential(double start, double factor, size_t count) { if (count < 1) { PROM_LOG("count must be less than 1"); return NULL; @@ -76,12 +75,12 @@ prom_histogram_buckets_t* prom_histogram_buckets_exponential(double start, doubl return NULL; } - prom_histogram_buckets_t *self = (prom_histogram_buckets_t*) prom_malloc(sizeof(prom_histogram_buckets_t)); + prom_histogram_buckets_t *self = (prom_histogram_buckets_t *)prom_malloc(sizeof(prom_histogram_buckets_t)); - double *upper_bounds = (double*) prom_malloc(sizeof(double) * count); + double *upper_bounds = (double *)prom_malloc(sizeof(double) * count); upper_bounds[0] = start; for (size_t i = 1; i < count; i++) { - upper_bounds[i] = upper_bounds[i-1] * factor; + upper_bounds[i] = upper_bounds[i - 1] * factor; } self->upper_bounds = upper_bounds; self->count = count; @@ -91,7 +90,7 @@ prom_histogram_buckets_t* prom_histogram_buckets_exponential(double start, doubl int prom_histogram_buckets_destroy(prom_histogram_buckets_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return 0; - prom_free((double *) self->upper_bounds); + prom_free((double *)self->upper_bounds); self->upper_bounds = NULL; prom_free(self); self = NULL; diff --git a/prom/src/prom_linked_list.c b/prom/src/prom_linked_list.c index 1dc3cbe..87d77eb 100644 --- a/prom/src/prom_linked_list.c +++ b/prom/src/prom_linked_list.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,9 +23,8 @@ #include "prom_linked_list_t.h" #include "prom_log.h" - -prom_linked_list_t* prom_linked_list_new(void) { - prom_linked_list_t *self = (prom_linked_list_t*) prom_malloc(sizeof(prom_linked_list_t)); +prom_linked_list_t *prom_linked_list_new(void) { + prom_linked_list_t *self = (prom_linked_list_t *)prom_malloc(sizeof(prom_linked_list_t)); self->head = NULL; self->tail = NULL; self->free_fn = NULL; @@ -87,10 +86,10 @@ void *prom_linked_list_last(prom_linked_list_t *self) { } } -int prom_linked_list_append(prom_linked_list_t *self, void *item){ +int prom_linked_list_append(prom_linked_list_t *self, void *item) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; - prom_linked_list_node_t *node = (prom_linked_list_node_t *) prom_malloc(sizeof(prom_linked_list_node_t)); + prom_linked_list_node_t *node = (prom_linked_list_node_t *)prom_malloc(sizeof(prom_linked_list_node_t)); node->item = item; if (self->tail) { @@ -104,10 +103,10 @@ int prom_linked_list_append(prom_linked_list_t *self, void *item){ return 0; } -int prom_linked_list_push(prom_linked_list_t *self, void *item){ +int prom_linked_list_push(prom_linked_list_t *self, void *item) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; - prom_linked_list_node_t *node = (prom_linked_list_node_t *) prom_malloc(sizeof(prom_linked_list_node_t)); + prom_linked_list_node_t *node = (prom_linked_list_node_t *)prom_malloc(sizeof(prom_linked_list_node_t)); node->item = item; node->next = self->head; @@ -123,16 +122,16 @@ void *prom_linked_list_pop(prom_linked_list_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return NULL; prom_linked_list_node_t *node = self->head; - void* item = NULL; - if (node != NULL){ + void *item = NULL; + if (node != NULL) { item = node->item; self->head = node->next; if (self->tail == node) { self->tail = NULL; } - if (node->item != NULL){ - if (self->free_fn){ - (*self->free_fn)(node->item); + if (node->item != NULL) { + if (self->free_fn) { + (*self->free_fn)(node->item); } else { prom_free(node->item); } @@ -144,7 +143,7 @@ void *prom_linked_list_pop(prom_linked_list_t *self) { return item; } -int prom_linked_list_remove(prom_linked_list_t *self, void* item) { +int prom_linked_list_remove(prom_linked_list_t *self, void *item) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; prom_linked_list_node_t *node; @@ -219,4 +218,4 @@ int prom_linked_list_set_compare_fn(prom_linked_list_t *self, prom_linked_list_c return 0; } -void prom_linked_list_no_op_free(void *item) { } +void prom_linked_list_no_op_free(void *item) {} diff --git a/prom/src/prom_linked_list_i.h b/prom/src/prom_linked_list_i.h index fc73f70..a0ed1b6 100644 --- a/prom/src/prom_linked_list_i.h +++ b/prom/src/prom_linked_list_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,14 +14,12 @@ * limitations under the License. */ - #ifndef PROM_LIST_I_INCLUDED #define PROM_LIST_I_INCLUDED // Private #include "prom_linked_list_t.h" - /** * @brief API PRIVATE Returns a pointer to a prom_linked_list */ @@ -40,12 +38,12 @@ int prom_linked_list_destroy(prom_linked_list_t *self); /** * @brief API PRIVATE Append an item to the back of the list */ -int prom_linked_list_append(prom_linked_list_t *self, void* item); +int prom_linked_list_append(prom_linked_list_t *self, void *item); /** * @brief API PRIVATE Push an item onto the front of the list */ -int prom_linked_list_push(prom_linked_list_t *self, void* item); +int prom_linked_list_push(prom_linked_list_t *self, void *item); /** * @brief API PRIVATE Pop the first item off of the list diff --git a/prom/src/prom_linked_list_t.h b/prom/src/prom_linked_list_t.h index b8851f4..f7d9e7e 100644 --- a/prom/src/prom_linked_list_t.h +++ b/prom/src/prom_linked_list_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,22 +14,17 @@ * limitations under the License. */ - #ifndef PROM_LIST_T_H #define PROM_LIST_T_H #include "prom_linked_list.h" -typedef enum { - PROM_LESS = -1, - PROM_EQUAL = 0, - PROM_GREATER = 1 -} prom_linked_list_compare_t; +typedef enum { PROM_LESS = -1, PROM_EQUAL = 0, PROM_GREATER = 1 } prom_linked_list_compare_t; /** * @brief API PRIVATE Frees an item in a prom_linked_list_node */ -typedef void (*prom_linked_list_free_item_fn)(void*); +typedef void (*prom_linked_list_free_item_fn)(void *); /** * @brief API PRIVATE Compares two items within a prom_linked_list @@ -41,7 +36,7 @@ typedef prom_linked_list_compare_t (*prom_linked_list_compare_item_fn)(void *ite * next prom_linked_list_node* */ typedef struct prom_linked_list_node { - struct prom_linked_list_node* next; + struct prom_linked_list_node *next; void *item; } prom_linked_list_node_t; @@ -56,5 +51,4 @@ struct prom_linked_list { prom_linked_list_compare_item_fn compare_fn; }; -#endif // PROM_LIST_T_H - +#endif // PROM_LIST_T_H diff --git a/prom/src/prom_log.h b/prom/src/prom_log.h index 5077e89..4209bdb 100644 --- a/prom/src/prom_log.h +++ b/prom/src/prom_log.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,9 +20,9 @@ #define PROM_LOG_H #ifdef PROM_LOG_ENABLE - #define PROM_LOG(msg) printf("%s %s %s %s %d %s\n", __DATE__, __TIME__, __FILE__, __FUNCTION__, __LINE__, msg); +#define PROM_LOG(msg) printf("%s %s %s %s %d %s\n", __DATE__, __TIME__, __FILE__, __FUNCTION__, __LINE__, msg); #else - #define PROM_LOG(msg) -#endif // PROM_LOG_ENABLE +#define PROM_LOG(msg) +#endif // PROM_LOG_ENABLE -#endif // PROM_LOG_H +#endif // PROM_LOG_H diff --git a/prom/src/prom_map.c b/prom/src/prom_map.c index 677c66d..3f21ba5 100644 --- a/prom/src/prom_map.c +++ b/prom/src/prom_map.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,21 +23,21 @@ // Private #include "prom_assert.h" #include "prom_errors.h" +#include "prom_linked_list_i.h" +#include "prom_linked_list_t.h" #include "prom_log.h" #include "prom_map_i.h" #include "prom_map_t.h" -#include "prom_linked_list_i.h" -#include "prom_linked_list_t.h" #define PROM_MAP_INITIAL_SIZE 32 -static void destroy_map_node_value_no_op(void* value) {} +static void destroy_map_node_value_no_op(void *value) {} //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // prom_map_node //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -prom_map_node_t* prom_map_node_new(const char *key, void *value, prom_map_node_free_value_fn free_value_fn) { +prom_map_node_t *prom_map_node_new(const char *key, void *value, prom_map_node_free_value_fn free_value_fn) { prom_map_node_t *self = prom_malloc(sizeof(prom_map_node_t)); self->key = prom_strdup(key); self->value = value; @@ -48,7 +48,7 @@ prom_map_node_t* prom_map_node_new(const char *key, void *value, prom_map_node_f int prom_map_node_destroy(prom_map_node_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return 0; - prom_free((void*) self->key); + prom_free((void *)self->key); self->key = NULL; if (self->value != NULL) (*self->free_value_fn)(self->value); self->value = NULL; @@ -58,13 +58,13 @@ int prom_map_node_destroy(prom_map_node_t *self) { } void prom_map_node_free(void *item) { - prom_map_node_t *map_node = (prom_map_node_t*) item; + prom_map_node_t *map_node = (prom_map_node_t *)item; prom_map_node_destroy(map_node); } prom_linked_list_compare_t prom_map_node_compare(void *item_a, void *item_b) { - prom_map_node_t *map_node_a = (prom_map_node_t *) item_a; - prom_map_node_t *map_node_b = (prom_map_node_t *) item_b; + prom_map_node_t *map_node_a = (prom_map_node_t *)item_a; + prom_map_node_t *map_node_b = (prom_map_node_t *)item_b; return strcmp(map_node_a->key, map_node_b->key); } @@ -73,10 +73,10 @@ prom_linked_list_compare_t prom_map_node_compare(void *item_a, void *item_b) { // prom_map //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -prom_map_t* prom_map_new() { +prom_map_t *prom_map_new() { int r = 0; - prom_map_t *self = (prom_map_t*) prom_malloc(sizeof(prom_map_t)); + prom_map_t *self = (prom_map_t *)prom_malloc(sizeof(prom_map_t)); self->size = 0; self->max_size = PROM_MAP_INITIAL_SIZE; @@ -108,7 +108,7 @@ prom_map_t* prom_map_new() { } } - self->rwlock = (pthread_rwlock_t *) prom_malloc(sizeof(pthread_rwlock_t)); + self->rwlock = (pthread_rwlock_t *)prom_malloc(sizeof(pthread_rwlock_t)); r = pthread_rwlock_init(self->rwlock, NULL); if (r) { PROM_LOG(PROM_PTHREAD_RWLOCK_INIT_ERROR); @@ -153,7 +153,7 @@ int prom_map_destroy(prom_map_t *self) { static size_t prom_map_get_index_internal(const char *key, size_t *size, size_t *max_size) { size_t index; size_t a = 31415, b = 27183; - for (index = 0; *key != '\0'; key++, a = a*b % (*max_size - 1)) { + for (index = 0; *key != '\0'; key++, a = a * b % (*max_size - 1)) { index = (a * index + *key) % *max_size; } return index; @@ -178,24 +178,14 @@ size_t prom_map_get_index(prom_map_t *self, const char *key) { return prom_map_get_index_internal(key, &self->size, &self->max_size); } - -static void* prom_map_get_internal(const char *key, - size_t *size, - size_t *max_size, - prom_linked_list_t *keys, - prom_linked_list_t **addrs, - prom_map_node_free_value_fn free_value_fn) -{ +static void *prom_map_get_internal(const char *key, size_t *size, size_t *max_size, prom_linked_list_t *keys, + prom_linked_list_t **addrs, prom_map_node_free_value_fn free_value_fn) { size_t index = prom_map_get_index_internal(key, size, max_size); prom_linked_list_t *list = addrs[index]; prom_map_node_t *temp_map_node = prom_map_node_new(key, NULL, free_value_fn); - for ( - prom_linked_list_node_t *current_node = list->head; - current_node != NULL; - current_node = current_node->next - ) { - prom_map_node_t *current_map_node = (prom_map_node_t*) current_node->item; + for (prom_linked_list_node_t *current_node = list->head; current_node != NULL; current_node = current_node->next) { + prom_map_node_t *current_map_node = (prom_map_node_t *)current_node->item; prom_linked_list_compare_t result = prom_linked_list_compare(list, current_map_node, temp_map_node); if (result == PROM_EQUAL) { prom_map_node_destroy(temp_map_node); @@ -208,7 +198,7 @@ static void* prom_map_get_internal(const char *key, return NULL; } -void* prom_map_get(prom_map_t *self, const char *key) { +void *prom_map_get(prom_map_t *self, const char *key) { PROM_ASSERT(self != NULL); int r = 0; r = pthread_rwlock_wrlock(self->rwlock); @@ -216,49 +206,33 @@ void* prom_map_get(prom_map_t *self, const char *key) { PROM_LOG(PROM_PTHREAD_RWLOCK_LOCK_ERROR); NULL; } - void *payload = prom_map_get_internal( - key, - &self->size, - &self->max_size, - self->keys, - self->addrs, - self->free_value_fn - ); + void *payload = + prom_map_get_internal(key, &self->size, &self->max_size, self->keys, self->addrs, self->free_value_fn); r = pthread_rwlock_unlock(self->rwlock); - if (r){ + if (r) { PROM_LOG(PROM_PTHREAD_RWLOCK_UNLOCK_ERROR); return NULL; } return payload; } -static int prom_map_set_internal(const char *key, - void *value, - size_t *size, - size_t *max_size, - prom_linked_list_t *keys, - prom_linked_list_t **addrs, - prom_map_node_free_value_fn free_value_fn, - bool destroy_current_value) -{ +static int prom_map_set_internal(const char *key, void *value, size_t *size, size_t *max_size, prom_linked_list_t *keys, + prom_linked_list_t **addrs, prom_map_node_free_value_fn free_value_fn, + bool destroy_current_value) { prom_map_node_t *map_node = prom_map_node_new(key, value, free_value_fn); if (map_node == NULL) return 1; size_t index = prom_map_get_index_internal(key, size, max_size); prom_linked_list_t *list = addrs[index]; - for ( - prom_linked_list_node_t *current_node = list->head; - current_node != NULL; - current_node = current_node->next - ) { - prom_map_node_t *current_map_node = (prom_map_node_t*) current_node->item; + for (prom_linked_list_node_t *current_node = list->head; current_node != NULL; current_node = current_node->next) { + prom_map_node_t *current_map_node = (prom_map_node_t *)current_node->item; prom_linked_list_compare_t result = prom_linked_list_compare(list, current_map_node, map_node); if (result == PROM_EQUAL) { if (destroy_current_value) { free_value_fn(current_map_node->value); current_map_node->value = NULL; } - prom_free((char *) current_map_node->key); + prom_free((char *)current_map_node->key); current_map_node->key = NULL; prom_free(current_map_node); current_map_node = NULL; @@ -267,7 +241,7 @@ static int prom_map_set_internal(const char *key, } } prom_linked_list_append(list, map_node); - prom_linked_list_append(keys, (char *) map_node->key); + prom_linked_list_append(keys, (char *)map_node->key); (*size)++; return 0; } @@ -310,23 +284,15 @@ int prom_map_ensure_space(prom_map_t *self) { prom_linked_list_t *list = self->addrs[i]; prom_linked_list_node_t *current_node = list->head; while (current_node != NULL) { - prom_map_node_t *map_node = (prom_map_node_t*) current_node->item; - r = prom_map_set_internal( - map_node->key, - map_node->value, - &new_size, - &new_max, - new_keys, - new_addrs, - self->free_value_fn, - false - ); + prom_map_node_t *map_node = (prom_map_node_t *)current_node->item; + r = prom_map_set_internal(map_node->key, map_node->value, &new_size, &new_max, new_keys, new_addrs, + self->free_value_fn, false); if (r) return r; prom_linked_list_node_t *next = current_node->next; prom_free(current_node); current_node = NULL; - prom_free((void *) map_node->key); + prom_free((void *)map_node->key); map_node->key = NULL; prom_free(map_node); map_node = NULL; @@ -373,16 +339,8 @@ int prom_map_set(prom_map_t *self, const char *key, void *value) { return r; } } - r = prom_map_set_internal( - key, - value, - &self->size, - &self->max_size, - self->keys, - self->addrs, - self->free_value_fn, - true - ); + r = prom_map_set_internal(key, value, &self->size, &self->max_size, self->keys, self->addrs, self->free_value_fn, + true); if (r) { int rr = 0; rr = pthread_rwlock_unlock(self->rwlock); @@ -400,30 +358,21 @@ int prom_map_set(prom_map_t *self, const char *key, void *value) { return r; } -static int prom_map_delete_internal(const char *key, - size_t *size, - size_t *max_size, - prom_linked_list_t *keys, - prom_linked_list_t **addrs, - prom_map_node_free_value_fn free_value_fn) -{ +static int prom_map_delete_internal(const char *key, size_t *size, size_t *max_size, prom_linked_list_t *keys, + prom_linked_list_t **addrs, prom_map_node_free_value_fn free_value_fn) { int r = 0; size_t index = prom_map_get_index_internal(key, size, max_size); prom_linked_list_t *list = addrs[index]; prom_map_node_t *temp_map_node = prom_map_node_new(key, NULL, free_value_fn); - for ( - prom_linked_list_node_t *current_node = list->head; - current_node != NULL; - current_node = current_node->next - ) { - prom_map_node_t *current_map_node = (prom_map_node_t*) current_node->item; + for (prom_linked_list_node_t *current_node = list->head; current_node != NULL; current_node = current_node->next) { + prom_map_node_t *current_map_node = (prom_map_node_t *)current_node->item; prom_linked_list_compare_t result = prom_linked_list_compare(list, current_map_node, temp_map_node); if (result == PROM_EQUAL) { r = prom_linked_list_remove(list, current_node); if (r) return r; - r = prom_linked_list_remove(keys, (char *) current_map_node->key); + r = prom_linked_list_remove(keys, (char *)current_map_node->key); if (r) return r; (*size)--; @@ -464,4 +413,3 @@ size_t prom_map_size(prom_map_t *self) { PROM_ASSERT(self != NULL); return self->size; } - diff --git a/prom/src/prom_map_i.h b/prom/src/prom_map_i.h index 09c26dc..9b6263b 100644 --- a/prom/src/prom_map_i.h +++ b/prom/src/prom_map_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,20 +14,18 @@ * limitations under the License. */ - - #ifndef PROM_MAP_I_INCLUDED #define PROM_MAP_I_INCLUDED #include "prom_map_t.h" -prom_map_t* prom_map_new(void); +prom_map_t *prom_map_new(void); int prom_map_set_free_value_fn(prom_map_t *self, prom_map_node_free_value_fn free_value_fn); -void* prom_map_get(prom_map_t *self, const char *key); +void *prom_map_get(prom_map_t *self, const char *key); -int prom_map_set(prom_map_t *self, const char *key, void *value); +int prom_map_set(prom_map_t *self, const char *key, void *value); int prom_map_delete(prom_map_t *self, const char *key); @@ -35,6 +33,6 @@ int prom_map_destroy(prom_map_t *self); size_t prom_map_size(prom_map_t *self); -prom_map_node_t* prom_map_node_new(const char *key, void *value, prom_map_node_free_value_fn free_value_fn); +prom_map_node_t *prom_map_node_new(const char *key, void *value, prom_map_node_free_value_fn free_value_fn); -#endif // PROM_MAP_I_INCLUDED \ No newline at end of file +#endif // PROM_MAP_I_INCLUDED diff --git a/prom/src/prom_map_t.h b/prom/src/prom_map_t.h index 544bc13..66832ee 100644 --- a/prom/src/prom_map_t.h +++ b/prom/src/prom_map_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,8 +14,6 @@ * limitations under the License. */ - - #ifndef PROM_MAP_T_H #define PROM_MAP_T_H @@ -27,7 +25,7 @@ // Private #include "prom_linked_list_t.h" -typedef void (*prom_map_node_free_value_fn)(void*); +typedef void (*prom_map_node_free_value_fn)(void *); struct prom_map_node { const char *key; @@ -36,13 +34,12 @@ struct prom_map_node { }; struct prom_map { - size_t size; /**< contains the size of the map */ - size_t max_size; /**< stores the current max_size */ - prom_linked_list_t *keys; /**< linked list containing containing all keys present */ - prom_linked_list_t **addrs; /**< Sequence of linked lists. Each list contains nodes with the same index */ + size_t size; /**< contains the size of the map */ + size_t max_size; /**< stores the current max_size */ + prom_linked_list_t *keys; /**< linked list containing containing all keys present */ + prom_linked_list_t **addrs; /**< Sequence of linked lists. Each list contains nodes with the same index */ pthread_rwlock_t *rwlock; prom_map_node_free_value_fn free_value_fn; }; - -#endif // PROM_MAP_T_H \ No newline at end of file +#endif // PROM_MAP_T_H diff --git a/prom/src/prom_metric.c b/prom/src/prom_metric.c index 47d7fdf..c095771 100644 --- a/prom/src/prom_metric.c +++ b/prom/src/prom_metric.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,32 +25,23 @@ #include "prom_errors.h" #include "prom_log.h" #include "prom_map_i.h" -#include "prom_metric_i.h" #include "prom_metric_formatter_i.h" -#include "prom_metric_sample_i.h" +#include "prom_metric_i.h" #include "prom_metric_sample_histogram_i.h" +#include "prom_metric_sample_i.h" + +char *prom_metric_type_map[4] = {"counter", "gauge", "histogram", "summary"}; -char *prom_metric_type_map[4] = { - "counter", - "gauge", - "histogram", - "summary" -}; - -prom_metric_t* prom_metric_new(prom_metric_type_t metric_type, - const char *name, - const char *help, - size_t label_key_count, - const char **label_keys) -{ +prom_metric_t *prom_metric_new(prom_metric_type_t metric_type, const char *name, const char *help, + size_t label_key_count, const char **label_keys) { int r = 0; - prom_metric_t *self = (prom_metric_t *) prom_malloc(sizeof(prom_metric_t)); + prom_metric_t *self = (prom_metric_t *)prom_malloc(sizeof(prom_metric_t)); self->type = metric_type; self->name = name; self->help = help; self->buckets = NULL; - const char **k = (const char **) prom_malloc(sizeof(const char *) * label_key_count); + const char **k = (const char **)prom_malloc(sizeof(const char *) * label_key_count); for (int i = 0; i < label_key_count; i++) { if (strcmp(label_keys[i], "le") == 0) { @@ -88,7 +79,7 @@ prom_metric_t* prom_metric_new(prom_metric_type_t metric_type, prom_metric_destroy(self); return NULL; } - self->rwlock = (pthread_rwlock_t*) prom_malloc(sizeof(pthread_rwlock_t)); + self->rwlock = (pthread_rwlock_t *)prom_malloc(sizeof(pthread_rwlock_t)); r = pthread_rwlock_init(self->rwlock, NULL); if (r) { PROM_LOG(PROM_PTHREAD_RWLOCK_INIT_ERROR); @@ -110,7 +101,6 @@ int prom_metric_destroy(prom_metric_t *self) { if (r) ret = r; } - r = prom_map_destroy(self->samples); self->samples = NULL; if (r) ret = r; @@ -129,7 +119,7 @@ int prom_metric_destroy(prom_metric_t *self) { self->rwlock = NULL; for (int i = 0; i < self->label_key_count; i++) { - prom_free((void *) self->label_keys[i]); + prom_free((void *)self->label_keys[i]); self->label_keys[i] = NULL; } prom_free(self->label_keys); @@ -143,18 +133,18 @@ int prom_metric_destroy(prom_metric_t *self) { int prom_metric_destroy_generic(void *item) { int r = 0; - prom_metric_t *self = (prom_metric_t *) item; + prom_metric_t *self = (prom_metric_t *)item; r = prom_metric_destroy(self); self = NULL; return r; } void prom_metric_free_generic(void *item) { - prom_metric_t *self = (prom_metric_t *) item; + prom_metric_t *self = (prom_metric_t *)item; prom_metric_destroy(self); } -prom_metric_sample_t* prom_metric_sample_from_labels(prom_metric_t *self, const char **label_values) { +prom_metric_sample_t *prom_metric_sample_from_labels(prom_metric_t *self, const char **label_values) { PROM_ASSERT(self != NULL); int r = 0; r = pthread_rwlock_wrlock(self->rwlock); @@ -163,21 +153,14 @@ prom_metric_sample_t* prom_metric_sample_from_labels(prom_metric_t *self, const return NULL; } - #define PROM_METRIC_SAMPLE_FROM_LABELS_HANDLE_UNLOCK() \ - r = pthread_rwlock_unlock(self->rwlock); \ - if (r) PROM_LOG(PROM_PTHREAD_RWLOCK_UNLOCK_ERROR); \ - return NULL; - +#define PROM_METRIC_SAMPLE_FROM_LABELS_HANDLE_UNLOCK() \ + r = pthread_rwlock_unlock(self->rwlock); \ + if (r) PROM_LOG(PROM_PTHREAD_RWLOCK_UNLOCK_ERROR); \ + return NULL; // Get l_value - r = prom_metric_formatter_load_l_value( - self->formatter, - self->name, - NULL, - self->label_key_count, - self->label_keys, - label_values - ); + r = prom_metric_formatter_load_l_value(self->formatter, self->name, NULL, self->label_key_count, self->label_keys, + label_values); if (r) { PROM_METRIC_SAMPLE_FROM_LABELS_HANDLE_UNLOCK(); } @@ -189,7 +172,7 @@ prom_metric_sample_t* prom_metric_sample_from_labels(prom_metric_t *self, const } // Get sample - prom_metric_sample_t *sample = (prom_metric_sample_t*) prom_map_get(self->samples, l_value); + prom_metric_sample_t *sample = (prom_metric_sample_t *)prom_map_get(self->samples, l_value); if (sample == NULL) { sample = prom_metric_sample_new(self->type, l_value, 0.0); r = prom_map_set(self->samples, l_value, sample); @@ -198,12 +181,12 @@ prom_metric_sample_t* prom_metric_sample_from_labels(prom_metric_t *self, const } } pthread_rwlock_unlock(self->rwlock); - prom_free((void *) l_value); + prom_free((void *)l_value); return sample; } -prom_metric_sample_histogram_t* prom_metric_sample_histogram_from_labels(prom_metric_t *self, const char **label_values) -{ +prom_metric_sample_histogram_t *prom_metric_sample_histogram_from_labels(prom_metric_t *self, + const char **label_values) { PROM_ASSERT(self != NULL); int r = 0; @@ -213,22 +196,16 @@ prom_metric_sample_histogram_t* prom_metric_sample_histogram_from_labels(prom_me return NULL; } - #define PROM_METRIC_SAMPLE_HISTOGRAM_FROM_LABELS_HANDLE_UNLOCK() \ - r = pthread_rwlock_unlock(self->rwlock); \ - if (r) { \ - PROM_LOG(PROM_PTHREAD_RWLOCK_UNLOCK_ERROR); \ - return NULL; \ - } +#define PROM_METRIC_SAMPLE_HISTOGRAM_FROM_LABELS_HANDLE_UNLOCK() \ + r = pthread_rwlock_unlock(self->rwlock); \ + if (r) { \ + PROM_LOG(PROM_PTHREAD_RWLOCK_UNLOCK_ERROR); \ + return NULL; \ + } // Load the l_value - r = prom_metric_formatter_load_l_value( - self->formatter, - self->name, - NULL, - self->label_key_count, - self->label_keys, - label_values - ); + r = prom_metric_formatter_load_l_value(self->formatter, self->name, NULL, self->label_key_count, self->label_keys, + label_values); if (r) { PROM_METRIC_SAMPLE_HISTOGRAM_FROM_LABELS_HANDLE_UNLOCK(); } @@ -240,23 +217,22 @@ prom_metric_sample_histogram_t* prom_metric_sample_histogram_from_labels(prom_me } // Get sample - prom_metric_sample_histogram_t *sample = (prom_metric_sample_histogram_t*) prom_map_get(self->samples, l_value); + prom_metric_sample_histogram_t *sample = (prom_metric_sample_histogram_t *)prom_map_get(self->samples, l_value); if (sample == NULL) { - sample = prom_metric_sample_histogram_new( - self->name, self->buckets, self->label_key_count, self->label_keys, label_values - ); + sample = prom_metric_sample_histogram_new(self->name, self->buckets, self->label_key_count, self->label_keys, + label_values); if (sample == NULL) { - prom_free((void *) l_value); + prom_free((void *)l_value); PROM_METRIC_SAMPLE_HISTOGRAM_FROM_LABELS_HANDLE_UNLOCK(); } r = prom_map_set(self->samples, l_value, sample); if (r) { - prom_free((void *) l_value); + prom_free((void *)l_value); pthread_rwlock_unlock(self->rwlock); PROM_METRIC_SAMPLE_HISTOGRAM_FROM_LABELS_HANDLE_UNLOCK(); } } pthread_rwlock_unlock(self->rwlock); - prom_free((void *) l_value); + prom_free((void *)l_value); return sample; } diff --git a/prom/src/prom_metric_formatter.c b/prom/src/prom_metric_formatter.c index 4858943..c8b3cf6 100644 --- a/prom/src/prom_metric_formatter.c +++ b/prom/src/prom_metric_formatter.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,18 +22,16 @@ // Private #include "prom_assert.h" #include "prom_collector_t.h" -#include "prom_metric_t.h" #include "prom_linked_list_t.h" -#include "prom_metric_sample_t.h" -#include "prom_metric_sample_histogram_t.h" - +#include "prom_map_i.h" #include "prom_metric_formatter_i.h" +#include "prom_metric_sample_histogram_t.h" +#include "prom_metric_sample_t.h" +#include "prom_metric_t.h" #include "prom_string_builder_i.h" -#include "prom_map_i.h" - -prom_metric_formatter_t* prom_metric_formatter_new() { - prom_metric_formatter_t *self = (prom_metric_formatter_t*) prom_malloc(sizeof(prom_metric_formatter_t)); +prom_metric_formatter_t *prom_metric_formatter_new() { + prom_metric_formatter_t *self = (prom_metric_formatter_t *)prom_malloc(sizeof(prom_metric_formatter_t)); self->string_builder = prom_string_builder_new(); if (self->string_builder == NULL) { prom_metric_formatter_destroy(self); @@ -67,7 +65,7 @@ int prom_metric_formatter_destroy(prom_metric_formatter_t *self) { return ret; } -int prom_metric_formatter_load_help(prom_metric_formatter_t* self, const char *name, const char *help) { +int prom_metric_formatter_load_help(prom_metric_formatter_t *self, const char *name, const char *help) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; @@ -88,7 +86,7 @@ int prom_metric_formatter_load_help(prom_metric_formatter_t* self, const char *n return prom_string_builder_add_char(self->string_builder, '\n'); } -int prom_metric_formatter_load_type(prom_metric_formatter_t* self, const char *name, prom_metric_type_t metric_type) { +int prom_metric_formatter_load_type(prom_metric_formatter_t *self, const char *name, prom_metric_type_t metric_type) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; @@ -109,13 +107,8 @@ int prom_metric_formatter_load_type(prom_metric_formatter_t* self, const char *n return prom_string_builder_add_char(self->string_builder, '\n'); } -int prom_metric_formatter_load_l_value(prom_metric_formatter_t* self, - const char *name, - const char *suffix, - size_t label_count, - const char **label_keys, - const char **label_values) -{ +int prom_metric_formatter_load_l_value(prom_metric_formatter_t *self, const char *name, const char *suffix, + size_t label_count, const char **label_keys, const char **label_values) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; @@ -139,7 +132,7 @@ int prom_metric_formatter_load_l_value(prom_metric_formatter_t* self, r = prom_string_builder_add_char(self->string_builder, '{'); if (r) return r; } - r = prom_string_builder_add_str(self->string_builder, (const char *) label_keys[i]); + r = prom_string_builder_add_str(self->string_builder, (const char *)label_keys[i]); if (r) return r; r = prom_string_builder_add_char(self->string_builder, '='); @@ -148,13 +141,13 @@ int prom_metric_formatter_load_l_value(prom_metric_formatter_t* self, r = prom_string_builder_add_char(self->string_builder, '"'); if (r) return r; - r = prom_string_builder_add_str(self->string_builder, (const char *) label_values[i]); + r = prom_string_builder_add_str(self->string_builder, (const char *)label_values[i]); if (r) return r; r = prom_string_builder_add_char(self->string_builder, '"'); if (r) return r; - if (i == label_count-1) { + if (i == label_count - 1) { r = prom_string_builder_add_char(self->string_builder, '}'); if (r) return r; } else { @@ -165,7 +158,7 @@ int prom_metric_formatter_load_l_value(prom_metric_formatter_t* self, return 0; } -int prom_metric_formatter_load_sample(prom_metric_formatter_t *self, prom_metric_sample_t *sample){ +int prom_metric_formatter_load_sample(prom_metric_formatter_t *self, prom_metric_sample_t *sample) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; @@ -190,7 +183,7 @@ int prom_metric_formatter_clear(prom_metric_formatter_t *self) { return prom_string_builder_clear(self->string_builder); } -char* prom_metric_formatter_dump(prom_metric_formatter_t *self) { +char *prom_metric_formatter_dump(prom_metric_formatter_t *self) { PROM_ASSERT(self != NULL); int r = 0; if (self == NULL) return NULL; @@ -216,32 +209,25 @@ int prom_metric_formatter_load_metric(prom_metric_formatter_t *self, prom_metric r = prom_metric_formatter_load_type(self, metric->name, metric->type); if (r) return r; - for ( - prom_linked_list_node_t *current_node = metric->samples->keys->head; - current_node != NULL; - current_node = current_node->next - ) { - const char *key = (const char *) current_node->item; + for (prom_linked_list_node_t *current_node = metric->samples->keys->head; current_node != NULL; + current_node = current_node->next) { + const char *key = (const char *)current_node->item; if (metric->type == PROM_HISTOGRAM) { - prom_metric_sample_histogram_t *hist_sample = (prom_metric_sample_histogram_t*) prom_map_get( - metric->samples, key - ); + prom_metric_sample_histogram_t *hist_sample = + (prom_metric_sample_histogram_t *)prom_map_get(metric->samples, key); if (hist_sample == NULL) return 1; - for ( - prom_linked_list_node_t *current_hist_node = hist_sample->l_value_list->head; - current_hist_node != NULL; - current_hist_node = current_hist_node->next - ) { - const char *hist_key = (const char *) current_hist_node->item; - prom_metric_sample_t *sample = (prom_metric_sample_t*) prom_map_get(hist_sample->samples, hist_key); + for (prom_linked_list_node_t *current_hist_node = hist_sample->l_value_list->head; current_hist_node != NULL; + current_hist_node = current_hist_node->next) { + const char *hist_key = (const char *)current_hist_node->item; + prom_metric_sample_t *sample = (prom_metric_sample_t *)prom_map_get(hist_sample->samples, hist_key); if (sample == NULL) return 1; r = prom_metric_formatter_load_sample(self, sample); if (r) return r; } } else { - prom_metric_sample_t *sample = (prom_metric_sample_t*) prom_map_get(metric->samples, key); + prom_metric_sample_t *sample = (prom_metric_sample_t *)prom_map_get(metric->samples, key); if (sample == NULL) return 1; r = prom_metric_formatter_load_sample(self, sample); if (r) return r; @@ -253,25 +239,19 @@ int prom_metric_formatter_load_metric(prom_metric_formatter_t *self, prom_metric int prom_metric_formatter_load_metrics(prom_metric_formatter_t *self, prom_map_t *collectors) { PROM_ASSERT(self != NULL); int r = 0; - for ( - prom_linked_list_node_t *current_node = collectors->keys->head; - current_node != NULL; - current_node = current_node->next - ) { - const char *collector_name = (const char *) current_node->item; - prom_collector_t *collector = (prom_collector_t *) prom_map_get(collectors, collector_name); + for (prom_linked_list_node_t *current_node = collectors->keys->head; current_node != NULL; + current_node = current_node->next) { + const char *collector_name = (const char *)current_node->item; + prom_collector_t *collector = (prom_collector_t *)prom_map_get(collectors, collector_name); if (collector == NULL) return 1; prom_map_t *metrics = collector->collect_fn(collector); if (metrics == NULL) return 1; - for ( - prom_linked_list_node_t *current_node = metrics->keys->head; - current_node != NULL; - current_node = current_node->next - ) { - const char *metric_name = (const char *) current_node->item; - prom_metric_t *metric = (prom_metric_t *) prom_map_get(metrics, metric_name); + for (prom_linked_list_node_t *current_node = metrics->keys->head; current_node != NULL; + current_node = current_node->next) { + const char *metric_name = (const char *)current_node->item; + prom_metric_t *metric = (prom_metric_t *)prom_map_get(metrics, metric_name); if (metric == NULL) return 1; r = prom_metric_formatter_load_metric(self, metric); if (r) return r; diff --git a/prom/src/prom_metric_formatter_i.h b/prom/src/prom_metric_formatter_i.h index b62cfe4..88eb93c 100644 --- a/prom/src/prom_metric_formatter_i.h +++ b/prom/src/prom_metric_formatter_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,10 +14,8 @@ * limitations under the License. */ - // Reference: https://prometheus.io/docs/instrumenting/exposition_formats/ - #ifndef PROM_METRIC_FORMATTER_I_H #define PROM_METRIC_FORMATTER_I_H @@ -28,23 +26,22 @@ /** * @brief API PRIVATE prom_metric_formatter constructor */ -prom_metric_formatter_t* prom_metric_formatter_new(); +prom_metric_formatter_t *prom_metric_formatter_new(); /** * @brief API PRIVATE prom_metric_formatter destructor */ int prom_metric_formatter_destroy(prom_metric_formatter_t *self); - /** * @brief API PRIVATE Loads the help text */ -int prom_metric_formatter_load_help(prom_metric_formatter_t* self, const char *name, const char *help); +int prom_metric_formatter_load_help(prom_metric_formatter_t *self, const char *name, const char *help); /** * @brief API PRIVATE Loads the type text */ -int prom_metric_formatter_load_type(prom_metric_formatter_t* self, const char *name, prom_metric_type_t metric_type); +int prom_metric_formatter_load_type(prom_metric_formatter_t *self, const char *name, prom_metric_type_t metric_type); /** * @brief API PRIVATE Loads the formatter with a metric sample L-value @@ -56,17 +53,13 @@ int prom_metric_formatter_load_type(prom_metric_formatter_t* self, const char *n * * The number of const char **and prom_label_value must be the same. */ -int prom_metric_formatter_load_l_value(prom_metric_formatter_t* metric_formatter, - const char *name, - const char *suffix, - size_t label_count, - const char **label_keys, - const char **label_values); +int prom_metric_formatter_load_l_value(prom_metric_formatter_t *metric_formatter, const char *name, const char *suffix, + size_t label_count, const char **label_keys, const char **label_values); /** * @brief API PRIVATE Loads the formatter with a metric sample */ -int prom_metric_formatter_load_sample(prom_metric_formatter_t* metric_formatter, prom_metric_sample_t *sample); +int prom_metric_formatter_load_sample(prom_metric_formatter_t *metric_formatter, prom_metric_sample_t *sample); /** * @brief API PRIVATE Loads a metric in the string exposition format @@ -86,7 +79,6 @@ int prom_metric_formatter_clear(prom_metric_formatter_t *self); /** * @brief API PRIVATE Returns the string built by prom_metric_formatter */ -char* prom_metric_formatter_dump(prom_metric_formatter_t* metric_formatter); - +char *prom_metric_formatter_dump(prom_metric_formatter_t *metric_formatter); -#endif // PROM_METRIC_FORMATTER_I_H +#endif // PROM_METRIC_FORMATTER_I_H diff --git a/prom/src/prom_metric_formatter_t.h b/prom/src/prom_metric_formatter_t.h index f6af729..5e50f4b 100644 --- a/prom/src/prom_metric_formatter_t.h +++ b/prom/src/prom_metric_formatter_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #ifndef PROM_METRIC_FORMATTER_T_H #define PROM_METRIC_FORMATTER_T_H @@ -25,4 +24,4 @@ typedef struct prom_metric_formatter { prom_string_builder_t *err_builder; } prom_metric_formatter_t; -#endif // PROM_METRIC_FORMATTER_T_H \ No newline at end of file +#endif // PROM_METRIC_FORMATTER_T_H diff --git a/prom/src/prom_metric_i.h b/prom/src/prom_metric_i.h index 310c63c..9fb1b1d 100644 --- a/prom/src/prom_metric_i.h +++ b/prom/src/prom_metric_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,8 @@ */ // Private -#include "prom_metric_t.h" #include "prom_metric_sample_histogram_t.h" +#include "prom_metric_t.h" #ifndef PROM_METRIC_I_INCLUDED #define PROM_METRIC_I_INCLUDED @@ -24,10 +24,7 @@ /** * @brief API PRIVATE Returns a *prom_metric */ -prom_metric_t* prom_metric_new(prom_metric_type_t type, - const char *name, - const char *help, - size_t label_key_count, +prom_metric_t *prom_metric_new(prom_metric_type_t type, const char *name, const char *help, size_t label_key_count, const char **label_keys); /** @@ -45,5 +42,4 @@ int prom_metric_destroy_generic(void *item); */ void prom_metric_free_generic(void *item); - #endif // PROM_METRIC_I_INCLUDED diff --git a/prom/src/prom_metric_sample.c b/prom/src/prom_metric_sample.c index ed9fbc2..6862548 100644 --- a/prom/src/prom_metric_sample.c +++ b/prom/src/prom_metric_sample.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #include // Public @@ -27,9 +26,8 @@ #include "prom_metric_sample_i.h" #include "prom_metric_sample_t.h" - -prom_metric_sample_t* prom_metric_sample_new(prom_metric_type_t type, const char *l_value, double r_value) { - prom_metric_sample_t *self = (prom_metric_sample_t*) prom_malloc(sizeof(prom_metric_sample_t)); +prom_metric_sample_t *prom_metric_sample_new(prom_metric_type_t type, const char *l_value, double r_value) { + prom_metric_sample_t *self = (prom_metric_sample_t *)prom_malloc(sizeof(prom_metric_sample_t)); self->type = type; self->l_value = prom_strdup(l_value); self->r_value = ATOMIC_VAR_INIT(r_value); @@ -39,9 +37,9 @@ prom_metric_sample_t* prom_metric_sample_new(prom_metric_type_t type, const char int prom_metric_sample_destroy(prom_metric_sample_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return 0; - prom_free((void *) self->l_value); + prom_free((void *)self->l_value); self->l_value = NULL; - prom_free((void *) self); + prom_free((void *)self); self = NULL; return 0; } @@ -49,14 +47,14 @@ int prom_metric_sample_destroy(prom_metric_sample_t *self) { int prom_metric_sample_destroy_generic(void *gen) { int r = 0; - prom_metric_sample_t *self = (prom_metric_sample_t*) gen; + prom_metric_sample_t *self = (prom_metric_sample_t *)gen; r = prom_metric_sample_destroy(self); self = NULL; return r; } void prom_metric_sample_free_generic(void *gen) { - prom_metric_sample_t *self = (prom_metric_sample_t*) gen; + prom_metric_sample_t *self = (prom_metric_sample_t *)gen; prom_metric_sample_destroy(self); } @@ -96,4 +94,4 @@ int prom_metric_sample_set(prom_metric_sample_t *self, double r_value) { } atomic_store(&self->r_value, r_value); return 0; -} \ No newline at end of file +} diff --git a/prom/src/prom_metric_sample_histogram.c b/prom/src/prom_metric_sample_histogram.c index 28533b7..faa3e4e 100644 --- a/prom/src/prom_metric_sample_histogram.c +++ b/prom/src/prom_metric_sample_histogram.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #include #include @@ -29,72 +28,53 @@ #include "prom_log.h" #include "prom_map_i.h" #include "prom_metric_formatter_i.h" -#include "prom_metric_sample_i.h" #include "prom_metric_sample_histogram_i.h" +#include "prom_metric_sample_i.h" //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Static Declarations //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -static const char* prom_metric_sample_histogram_l_value_for_bucket(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, - const char **label_values, +static const char *prom_metric_sample_histogram_l_value_for_bucket(prom_metric_sample_histogram_t *self, + const char *name, size_t label_count, + const char **label_keys, const char **label_values, double bucket); -static const char* prom_metric_sample_histogram_l_value_for_inf(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, +static const char *prom_metric_sample_histogram_l_value_for_inf(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, const char **label_values); static void prom_metric_sample_histogram_free_str_generic(void *gen); -static int prom_metric_sample_histogram_init_bucket_samples(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, +static int prom_metric_sample_histogram_init_bucket_samples(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, const char **label_values); -static int prom_metric_sample_histogram_init_inf(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, +static int prom_metric_sample_histogram_init_inf(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, const char **label_values); -static int prom_metric_sample_histogram_init_count(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, +static int prom_metric_sample_histogram_init_count(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, const char **label_values); -static int prom_metric_sample_histogram_init_summary(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, +static int prom_metric_sample_histogram_init_summary(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, const char **label_values); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // End static declarations //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - - -prom_metric_sample_histogram_t* prom_metric_sample_histogram_new(const char *name, - prom_histogram_buckets_t *buckets, - size_t label_count, - const char **label_keys, - const char **label_values) -{ +prom_metric_sample_histogram_t *prom_metric_sample_histogram_new(const char *name, prom_histogram_buckets_t *buckets, + size_t label_count, const char **label_keys, + const char **label_values) { // Capture return codes int r = 0; // Allocate and set self - prom_metric_sample_histogram_t *self = (prom_metric_sample_histogram_t*) prom_malloc( - sizeof(prom_metric_sample_histogram_t) - ); + prom_metric_sample_histogram_t *self = + (prom_metric_sample_histogram_t *)prom_malloc(sizeof(prom_metric_sample_histogram_t)); // Allocate and set the l_value_list self->l_value_list = prom_linked_list_new(); @@ -110,8 +90,8 @@ prom_metric_sample_histogram_t* prom_metric_sample_histogram_new(const char *nam return NULL; } - // Store map of l_value/prom_metric_sample_t - self->samples = prom_map_new(); + // Store map of l_value/prom_metric_sample_t + self->samples = prom_map_new(); if (self->samples == NULL) { prom_metric_sample_histogram_destroy(self); return NULL; @@ -125,7 +105,7 @@ prom_metric_sample_histogram_t* prom_metric_sample_histogram_new(const char *nam } // Set a map of bucket: l_value - self->l_values = prom_map_new(); // Store map of bucket/l_value + self->l_values = prom_map_new(); // Store map of bucket/l_value if (self->l_values == NULL) { prom_metric_sample_histogram_destroy(self); return NULL; @@ -141,7 +121,7 @@ prom_metric_sample_histogram_t* prom_metric_sample_histogram_new(const char *nam self->buckets = buckets; // Allocate and initialize the lock - self->rwlock = (pthread_rwlock_t *) prom_malloc(sizeof(pthread_rwlock_t)); + self->rwlock = (pthread_rwlock_t *)prom_malloc(sizeof(pthread_rwlock_t)); r = pthread_rwlock_init(self->rwlock, NULL); if (r) { prom_metric_sample_histogram_destroy(self); @@ -155,7 +135,6 @@ prom_metric_sample_histogram_t* prom_metric_sample_histogram_new(const char *nam return NULL; } - // Allocate and initialize the +Inf metric sample r = prom_metric_sample_histogram_init_inf(self, name, label_count, label_keys, label_values); if (r) { @@ -186,12 +165,9 @@ prom_metric_sample_histogram_t* prom_metric_sample_histogram_new(const char *nam return self; } -static int prom_metric_sample_histogram_init_bucket_samples(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, - const char **label_values) -{ +static int prom_metric_sample_histogram_init_bucket_samples(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, + const char **label_values) { PROM_ASSERT(self); int r = 0; int bucket_count = prom_histogram_buckets_count(self->buckets); @@ -199,9 +175,8 @@ static int prom_metric_sample_histogram_init_bucket_samples(prom_metric_sample_h // For each bucket, create an prom_metric_sample_t with an appropriate l_value and default value of 0.0. The // l_value will contain the metric name, user labels, and finally, the le label and bucket value. for (int i = 0; i < bucket_count; i++) { - const char *l_value = prom_metric_sample_histogram_l_value_for_bucket( - self, name, label_count, label_keys, label_values, self->buckets->upper_bounds[i] - ); + const char *l_value = prom_metric_sample_histogram_l_value_for_bucket(self, name, label_count, label_keys, + label_values, self->buckets->upper_bounds[i]); if (l_value == NULL) return 1; r = prom_linked_list_append(self->l_value_list, prom_strdup(l_value)); @@ -210,7 +185,7 @@ static int prom_metric_sample_histogram_init_bucket_samples(prom_metric_sample_h const char *bucket_key = prom_metric_sample_histogram_bucket_to_str(self->buckets->upper_bounds[i]); if (bucket_key == NULL) return 1; - r = prom_map_set(self->l_values, bucket_key, (char *) l_value); + r = prom_map_set(self->l_values, bucket_key, (char *)l_value); if (r) return r; prom_metric_sample_t *sample = prom_metric_sample_new(PROM_HISTOGRAM, l_value, 0.0); @@ -219,42 +194,35 @@ static int prom_metric_sample_histogram_init_bucket_samples(prom_metric_sample_h r = prom_map_set(self->samples, l_value, sample); if (r) return r; - prom_free((void *) bucket_key); + prom_free((void *)bucket_key); } return 0; } -static int prom_metric_sample_histogram_init_inf(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, - const char **label_values) -{ +static int prom_metric_sample_histogram_init_inf(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, + const char **label_values) { PROM_ASSERT(self != NULL); int r = 0; - const char *inf_l_value = prom_metric_sample_histogram_l_value_for_inf( - self, name, label_count, label_keys, label_values - ); + const char *inf_l_value = + prom_metric_sample_histogram_l_value_for_inf(self, name, label_count, label_keys, label_values); if (inf_l_value == NULL) return 1; r = prom_linked_list_append(self->l_value_list, prom_strdup(inf_l_value)); if (r) return r; - r = prom_map_set(self->l_values, "+Inf", (char *) inf_l_value); + r = prom_map_set(self->l_values, "+Inf", (char *)inf_l_value); if (r) return r; - prom_metric_sample_t *inf_sample = prom_metric_sample_new(PROM_HISTOGRAM, (char *) inf_l_value, 0.0); + prom_metric_sample_t *inf_sample = prom_metric_sample_new(PROM_HISTOGRAM, (char *)inf_l_value, 0.0); if (inf_sample == NULL) return 1; return prom_map_set(self->samples, inf_l_value, inf_sample); } -static int prom_metric_sample_histogram_init_count(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, - const char **label_values) -{ +static int prom_metric_sample_histogram_init_count(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, + const char **label_values) { PROM_ASSERT(self != NULL); int r = 0; @@ -267,7 +235,7 @@ static int prom_metric_sample_histogram_init_count(prom_metric_sample_histogram_ r = prom_linked_list_append(self->l_value_list, prom_strdup(count_l_value)); if (r) return r; - r = prom_map_set(self->l_values, "count", (char *) count_l_value); + r = prom_map_set(self->l_values, "count", (char *)count_l_value); if (r) return r; prom_metric_sample_t *count_sample = prom_metric_sample_new(PROM_HISTOGRAM, count_l_value, 0.0); @@ -276,12 +244,9 @@ static int prom_metric_sample_histogram_init_count(prom_metric_sample_histogram_ return prom_map_set(self->samples, count_l_value, count_sample); } -static int prom_metric_sample_histogram_init_summary(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, - const char **label_values) -{ +static int prom_metric_sample_histogram_init_summary(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, + const char **label_values) { PROM_ASSERT(self != NULL); int r = 0; @@ -294,7 +259,7 @@ static int prom_metric_sample_histogram_init_summary(prom_metric_sample_histogra r = prom_linked_list_append(self->l_value_list, prom_strdup(sum_l_value)); if (r) return r; - r = prom_map_set(self->l_values, "sum", (char *) sum_l_value); + r = prom_map_set(self->l_values, "sum", (char *)sum_l_value); if (r) return r; prom_metric_sample_t *sum_sample = prom_metric_sample_new(PROM_HISTOGRAM, sum_l_value, 0.0); @@ -303,7 +268,6 @@ static int prom_metric_sample_histogram_init_summary(prom_metric_sample_histogra return prom_map_set(self->samples, sum_l_value, sum_sample); } - int prom_metric_sample_histogram_destroy(prom_metric_sample_histogram_t *self) { PROM_ASSERT(self != NULL); int r = 0; @@ -341,14 +305,14 @@ int prom_metric_sample_histogram_destroy(prom_metric_sample_histogram_t *self) { int prom_metric_sample_histogram_destroy_generic(void *gen) { int r = 0; - prom_metric_sample_histogram_t *self = (prom_metric_sample_histogram_t*) gen; + prom_metric_sample_histogram_t *self = (prom_metric_sample_histogram_t *)gen; r = prom_metric_sample_histogram_destroy(self); self = NULL; return r; } void prom_metric_sample_histogram_free_generic(void *gen) { - prom_metric_sample_histogram_t *self = (prom_metric_sample_histogram_t*) gen; + prom_metric_sample_histogram_t *self = (prom_metric_sample_histogram_t *)gen; prom_metric_sample_histogram_destroy(self); } @@ -362,15 +326,15 @@ int prom_metric_sample_histogram_observe(prom_metric_sample_histogram_t *self, d return r; } - #define PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(r) \ - int rr = 0; \ - rr = pthread_rwlock_unlock(self->rwlock); \ - if (rr) { \ - PROM_LOG(PROM_PTHREAD_RWLOCK_UNLOCK_ERROR); \ - return rr; \ - } else { \ - return r; \ - } +#define PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(r) \ + int rr = 0; \ + rr = pthread_rwlock_unlock(self->rwlock); \ + if (rr) { \ + PROM_LOG(PROM_PTHREAD_RWLOCK_UNLOCK_ERROR); \ + return rr; \ + } else { \ + return r; \ + } // Update the counter for the proper bucket if found int bucket_count = prom_histogram_buckets_count(self->buckets); @@ -379,7 +343,6 @@ int prom_metric_sample_histogram_observe(prom_metric_sample_histogram_t *self, d break; } - const char *bucket_key = prom_metric_sample_histogram_bucket_to_str(self->buckets->upper_bounds[i]); if (bucket_key == NULL) { PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(1) @@ -387,17 +350,17 @@ int prom_metric_sample_histogram_observe(prom_metric_sample_histogram_t *self, d const char *l_value = prom_map_get(self->l_values, bucket_key); if (l_value == NULL) { - prom_free((void *) bucket_key); + prom_free((void *)bucket_key); PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(1) } prom_metric_sample_t *sample = prom_map_get(self->samples, l_value); if (sample == NULL) { - prom_free((void *) bucket_key); + prom_free((void *)bucket_key); PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(1) } - prom_free((void *) bucket_key); + prom_free((void *)bucket_key); r = prom_metric_sample_add(sample, 1.0); if (r) { PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(r); @@ -441,7 +404,7 @@ int prom_metric_sample_histogram_observe(prom_metric_sample_histogram_t *self, d PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(1); } - prom_metric_sample_t *sum_sample = prom_map_get(self->samples, sum_l_value); + prom_metric_sample_t *sum_sample = prom_map_get(self->samples, sum_l_value); if (sum_sample == NULL) { PROM_METRIC_SAMPLE_HISTOGRAM_OBSERVE_HANDLE_UNLOCK(1); } @@ -451,101 +414,93 @@ int prom_metric_sample_histogram_observe(prom_metric_sample_histogram_t *self, d return r; } -static const char* prom_metric_sample_histogram_l_value_for_bucket(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, - const char **label_values, - double bucket) -{ +static const char *prom_metric_sample_histogram_l_value_for_bucket(prom_metric_sample_histogram_t *self, + const char *name, size_t label_count, + const char **label_keys, const char **label_values, + double bucket) { PROM_ASSERT(self != NULL); int r = 0; - #define PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_BUCKET_CLEANUP() \ - for (size_t i = 0; i < label_count+1; i++) { \ - prom_free((char*) new_keys[i]); \ - prom_free((char*) new_values[i]); \ - } \ - prom_free(new_keys); \ - prom_free(new_values); +#define PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_BUCKET_CLEANUP() \ + for (size_t i = 0; i < label_count + 1; i++) { \ + prom_free((char *)new_keys[i]); \ + prom_free((char *)new_values[i]); \ + } \ + prom_free(new_keys); \ + prom_free(new_values); // Make new array to hold label_keys with le label key - const char **new_keys = (const char **) prom_malloc((label_count + 1) * sizeof(char*)); + const char **new_keys = (const char **)prom_malloc((label_count + 1) * sizeof(char *)); for (size_t i = 0; i < label_count; i++) { new_keys[i] = prom_strdup(label_keys[i]); } new_keys[label_count] = prom_strdup("le"); - // Make new array to hold label_values with le label value - const char **new_values = (const char **) prom_malloc((label_count+1) * sizeof(char*)); + const char **new_values = (const char **)prom_malloc((label_count + 1) * sizeof(char *)); for (size_t i = 0; i < label_count; i++) { new_values[i] = prom_strdup(label_values[i]); } new_values[label_count] = prom_metric_sample_histogram_bucket_to_str(bucket); - r = prom_metric_formatter_load_l_value(self->metric_formatter, name, NULL, label_count+1, new_keys, new_values); + r = prom_metric_formatter_load_l_value(self->metric_formatter, name, NULL, label_count + 1, new_keys, new_values); if (r) { PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_BUCKET_CLEANUP(); return NULL; } - const char *ret = (const char*) prom_metric_formatter_dump(self->metric_formatter); + const char *ret = (const char *)prom_metric_formatter_dump(self->metric_formatter); PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_BUCKET_CLEANUP(); return ret; } -static const char* prom_metric_sample_histogram_l_value_for_inf(prom_metric_sample_histogram_t *self, - const char *name, - size_t label_count, - const char **label_keys, - const char **label_values) -{ +static const char *prom_metric_sample_histogram_l_value_for_inf(prom_metric_sample_histogram_t *self, const char *name, + size_t label_count, const char **label_keys, + const char **label_values) { PROM_ASSERT(self != NULL); int r = 0; - #define PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_INF_CLEANUP() \ - for (size_t i = 0; i < label_count+1; i++) { \ - prom_free((char*) new_keys[i]); \ - prom_free((char*) new_values[i]); \ - } \ - prom_free(new_keys); \ - prom_free(new_values); +#define PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_INF_CLEANUP() \ + for (size_t i = 0; i < label_count + 1; i++) { \ + prom_free((char *)new_keys[i]); \ + prom_free((char *)new_values[i]); \ + } \ + prom_free(new_keys); \ + prom_free(new_values); - // Make new array to hold label_keys with le label key - const char **new_keys = (const char **) prom_malloc((label_count + 1) * sizeof(char*)); + // Make new array to hold label_keys with le label key + const char **new_keys = (const char **)prom_malloc((label_count + 1) * sizeof(char *)); for (size_t i = 0; i < label_count; i++) { new_keys[i] = prom_strdup(label_keys[i]); } new_keys[label_count] = prom_strdup("le"); - // Make new array to hold label_values with le label value - const char **new_values = (const char **) prom_malloc((label_count+1) * sizeof(char*)); + const char **new_values = (const char **)prom_malloc((label_count + 1) * sizeof(char *)); for (size_t i = 0; i < label_count; i++) { new_values[i] = prom_strdup(label_values[i]); } new_values[label_count] = prom_strdup("+Inf"); - r = prom_metric_formatter_load_l_value(self->metric_formatter, name, NULL, label_count+1, new_keys, new_values); + r = prom_metric_formatter_load_l_value(self->metric_formatter, name, NULL, label_count + 1, new_keys, new_values); if (r) { PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_INF_CLEANUP() return NULL; } - const char *ret = (const char*) prom_metric_formatter_dump(self->metric_formatter); + const char *ret = (const char *)prom_metric_formatter_dump(self->metric_formatter); PROM_METRIC_SAMPLE_HISTOGRAM_L_VALUE_FOR_INF_CLEANUP() return ret; } static void prom_metric_sample_histogram_free_str_generic(void *gen) { - char * str = (char *) gen; - prom_free((void *) str); + char *str = (char *)gen; + prom_free((void *)str); str = NULL; } -char* prom_metric_sample_histogram_bucket_to_str(double bucket) { - char *buf = (char*) prom_malloc(sizeof(char) * 50); +char *prom_metric_sample_histogram_bucket_to_str(double bucket) { + char *buf = (char *)prom_malloc(sizeof(char) * 50); sprintf(buf, "%f", bucket); return buf; -} \ No newline at end of file +} diff --git a/prom/src/prom_metric_sample_histogram_i.h b/prom/src/prom_metric_sample_histogram_i.h index 906afd8..325ca12 100644 --- a/prom/src/prom_metric_sample_histogram_i.h +++ b/prom/src/prom_metric_sample_histogram_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #ifndef PROM_METRIC_HISTOGRAM_SAMPLE_I_H #define PROM_METRIC_HISTOGRAM_SAMPLE_I_H @@ -27,10 +26,8 @@ /** * @brief API PRIVATE Create a pointer to a prom_metric_sample_histogram_t */ -prom_metric_sample_histogram_t* prom_metric_sample_histogram_new(const char *name, - prom_histogram_buckets_t *buckets, - size_t label_count, - const char **label_keys, +prom_metric_sample_histogram_t *prom_metric_sample_histogram_new(const char *name, prom_histogram_buckets_t *buckets, + size_t label_count, const char **label_keys, const char **label_vales); /** @@ -43,8 +40,8 @@ int prom_metric_sample_histogram_destroy(prom_metric_sample_histogram_t *self); */ int prom_metric_sample_histogram_destroy_generic(void *gen); -char* prom_metric_sample_histogram_bucket_to_str(double bucket); +char *prom_metric_sample_histogram_bucket_to_str(double bucket); void prom_metric_sample_histogram_free_generic(void *gen); -#endif // PROM_METRIC_HISTOGRAM_SAMPLE_I_H \ No newline at end of file +#endif // PROM_METRIC_HISTOGRAM_SAMPLE_I_H diff --git a/prom/src/prom_metric_sample_histogram_t.h b/prom/src/prom_metric_sample_histogram_t.h index d53c7c2..18cabb3 100644 --- a/prom/src/prom_metric_sample_histogram_t.h +++ b/prom/src/prom_metric_sample_histogram_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -36,4 +36,4 @@ struct prom_metric_sample_histogram { pthread_rwlock_t *rwlock; }; -#endif // PROM_METRIC_HISTOGRAM_SAMPLE_T_H \ No newline at end of file +#endif // PROM_METRIC_HISTOGRAM_SAMPLE_T_H diff --git a/prom/src/prom_metric_sample_i.h b/prom/src/prom_metric_sample_i.h index 901f275..eeb63ac 100644 --- a/prom/src/prom_metric_sample_i.h +++ b/prom/src/prom_metric_sample_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,8 +14,8 @@ * limitations under the License. */ -#include "prom_metric_t.h" #include "prom_metric_sample_t.h" +#include "prom_metric_t.h" #ifndef PROM_METRIC_SAMPLE_I_H #define PROM_METRIC_SAMPLE_I_H @@ -27,7 +27,7 @@ * @param l_value The entire left value of the metric e.g metric_name{foo="bar"} * @param r_value A double representing the value of the sample */ -prom_metric_sample_t* prom_metric_sample_new(prom_metric_type_t type, const char *l_value, double r_value); +prom_metric_sample_t *prom_metric_sample_new(prom_metric_type_t type, const char *l_value, double r_value); /** * @brief API PRIVATE Destroy the prom_metric_sample** @@ -39,7 +39,6 @@ int prom_metric_sample_destroy(prom_metric_sample_t *self); */ int prom_metric_sample_destroy_generic(void *); - /** * @brief API PRIVATE A prom_linked_list_free_item_fn to enable item destruction within a linked list's destructor. * @@ -47,4 +46,4 @@ int prom_metric_sample_destroy_generic(void *); */ void prom_metric_sample_free_generic(void *gen); -#endif // PROM_METRIC_SAMPLE_I_H \ No newline at end of file +#endif // PROM_METRIC_SAMPLE_I_H diff --git a/prom/src/prom_metric_sample_t.h b/prom/src/prom_metric_sample_t.h index 35f2e4a..26e533f 100644 --- a/prom/src/prom_metric_sample_t.h +++ b/prom/src/prom_metric_sample_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,20 +14,16 @@ * limitations under the License. */ - #ifndef PROM_METRIC_SAMPLE_T_H #define PROM_METRIC_SAMPLE_T_H -#include "prom_metric_t.h" #include "prom_metric_sample.h" +#include "prom_metric_t.h" struct prom_metric_sample { - prom_metric_type_t type; /**< type is the metric type for the sample */ + prom_metric_type_t type; /**< type is the metric type for the sample */ char *l_value; /**< l_value is the full metric name and label set represeted as a string */ _Atomic double r_value; /**< r_value is the value of the metric sample */ }; #endif // PROM_METRIC_SAMPLE_T_H - - - diff --git a/prom/src/prom_metric_t.h b/prom/src/prom_metric_t.h index 17e0847..4ab2706 100644 --- a/prom/src/prom_metric_t.h +++ b/prom/src/prom_metric_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,24 +20,18 @@ #include // Public -#include "prom_metric.h" #include "prom_histogram_buckets.h" +#include "prom_metric.h" // Private -#include "prom_metric_formatter_t.h" #include "prom_map_i.h" #include "prom_map_t.h" - +#include "prom_metric_formatter_t.h" /** * @brief API PRIVATE Contains metric type constants */ -typedef enum prom_metric_type { - PROM_COUNTER, - PROM_GAUGE, - PROM_HISTOGRAM, - PROM_SUMMARY -} prom_metric_type_t; +typedef enum prom_metric_type { PROM_COUNTER, PROM_GAUGE, PROM_HISTOGRAM, PROM_SUMMARY } prom_metric_type_t; /** * @brief API PRIVATE Maps metric type constants to human readable string values @@ -45,19 +39,19 @@ typedef enum prom_metric_type { extern char *prom_metric_type_map[4]; /** - * @brief API PRIVATE An opaque struct to users containing metric metadata; one or more metric samples; and a metric formatter - * for locating metric samples and exporting metric data + * @brief API PRIVATE An opaque struct to users containing metric metadata; one or more metric samples; and a metric + * formatter for locating metric samples and exporting metric data */ struct prom_metric { prom_metric_type_t type; /**< metric_type The type of metric */ const char *name; /**< name The name of the metric */ const char *help; /**< help The help output for the metric */ prom_map_t *samples; /**< samples Map comprised of samples for the given metric */ - prom_histogram_buckets_t* buckets; /**< buckets Array of histogram bucket upper bound values */ + prom_histogram_buckets_t *buckets; /**< buckets Array of histogram bucket upper bound values */ size_t label_key_count; /**< label_keys_count The count of labe_keys*/ prom_metric_formatter_t *formatter; /**< formatter The metric formatter */ pthread_rwlock_t *rwlock; /**< rwlock Required for locking on certain non-atomic operations */ const char **label_keys; /**< labels Array comprised of const char **/ }; -#endif // PROM_METRIC_T_H +#endif // PROM_METRIC_T_H diff --git a/prom/src/prom_process_fds.c b/prom/src/prom_process_fds.c index 4451782..7ffcbc8 100644 --- a/prom/src/prom_process_fds.c +++ b/prom/src/prom_process_fds.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,10 +14,8 @@ * limitations under the License. */ - - -#include #include +#include #include #include @@ -37,14 +35,14 @@ int prom_process_fds_count(const char *path) { int r = 0; struct dirent *de; DIR *d; - if (path) { + if (path) { d = opendir(path); if (d == NULL) { PROM_LOG(PROM_STDIO_OPEN_DIR_ERROR); return -1; } } else { - int pid = (int) getpid(); + int pid = (int)getpid(); char p[50]; sprintf(p, "/proc/%d/fd", pid); d = opendir(p); @@ -68,12 +66,7 @@ int prom_process_fds_count(const char *path) { return count; } - int prom_process_fds_init(void) { - prom_process_open_fds = prom_gauge_new( - "process_open_fds", - "Number of open file descriptors.", - 0, NULL - ); + prom_process_open_fds = prom_gauge_new("process_open_fds", "Number of open file descriptors.", 0, NULL); return 0; } diff --git a/prom/src/prom_process_fds_i.h b/prom/src/prom_process_fds_i.h index 1e10c85..b62268a 100644 --- a/prom/src/prom_process_fds_i.h +++ b/prom/src/prom_process_fds_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,12 +14,10 @@ * limitations under the License. */ - #ifndef PROM_PROESS_FDS_I_INCLUDED #define PROM_PROESS_FDS_I_INCLUDED - int prom_process_fds_count(const char *path); int prom_process_fds_init(void); -#endif // PROM_PROESS_FDS_I_INCLUDED \ No newline at end of file +#endif // PROM_PROESS_FDS_I_INCLUDED diff --git a/prom/src/prom_process_fds_t.h b/prom/src/prom_process_fds_t.h index e0e73c6..d46daae 100644 --- a/prom/src/prom_process_fds_t.h +++ b/prom/src/prom_process_fds_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,4 +21,4 @@ extern prom_gauge_t *prom_process_open_fds; -#endif // PROM_PROESS_FDS_T_H +#endif // PROM_PROESS_FDS_T_H diff --git a/prom/src/prom_process_limits.c b/prom/src/prom_process_limits.c index fcc8649..df83949 100644 --- a/prom/src/prom_process_limits.c +++ b/prom/src/prom_process_limits.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #include #include #include @@ -29,18 +28,16 @@ // Private #include "prom_assert.h" #include "prom_map_i.h" -#include "prom_procfs_i.h" #include "prom_process_limits_i.h" #include "prom_process_limits_t.h" +#include "prom_procfs_i.h" +const char PROM_PROCESS_LIMITS_RDP_LETTERS[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', + 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; -const char PROM_PROCESS_LIMITS_RDP_LETTERS[] = { - 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', - 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', - 'U', 'V', 'W', 'X', 'Y', 'Z' -}; - -const char PROM_PROCESS_LIMITS_RDP_DIGITS[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' } ; +const char PROM_PROCESS_LIMITS_RDP_DIGITS[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}; const char *PROM_PROCESS_LIMITS_RDP_UNLIMITED = "unlimited"; @@ -56,12 +53,9 @@ prom_gauge_t *prom_process_max_fds; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // prom_process_limits_row_t -prom_process_limits_row_t* prom_process_limits_row_new(const char *limit, - const int soft, - const int hard, - const char *units) -{ - prom_process_limits_row_t *self = (prom_process_limits_row_t*) prom_malloc(sizeof(prom_process_limits_row_t)); +prom_process_limits_row_t *prom_process_limits_row_new(const char *limit, const int soft, const int hard, + const char *units) { + prom_process_limits_row_t *self = (prom_process_limits_row_t *)prom_malloc(sizeof(prom_process_limits_row_t)); self->limit = prom_strdup(limit); self->units = prom_strdup(units); @@ -75,10 +69,10 @@ prom_process_limits_row_t* prom_process_limits_row_new(const char *limit, int prom_process_limits_row_destroy(prom_process_limits_row_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return 0; - prom_free((void *) self->limit); + prom_free((void *)self->limit); self->limit = NULL; - prom_free((void *) self->units); + prom_free((void *)self->units); self->units = NULL; prom_free(self); @@ -86,10 +80,9 @@ int prom_process_limits_row_destroy(prom_process_limits_row_t *self) { return 0; } -prom_process_limits_current_row_t* prom_process_limits_current_row_new(void) { - prom_process_limits_current_row_t *self = (prom_process_limits_current_row_t *) prom_malloc( - sizeof(prom_process_limits_current_row_t) - ); +prom_process_limits_current_row_t *prom_process_limits_current_row_new(void) { + prom_process_limits_current_row_t *self = + (prom_process_limits_current_row_t *)prom_malloc(sizeof(prom_process_limits_current_row_t)); self->limit = NULL; self->soft = 0; @@ -105,7 +98,7 @@ int prom_process_limits_current_row_set_limit(prom_process_limits_current_row_t } int prom_process_limits_current_row_set_units(prom_process_limits_current_row_t *self, char *units) { - PROM_ASSERT(self != NULL); + PROM_ASSERT(self != NULL); self->units = prom_strdup(units); return 0; } @@ -113,11 +106,11 @@ int prom_process_limits_current_row_set_units(prom_process_limits_current_row_t int prom_process_limits_current_row_clear(prom_process_limits_current_row_t *self) { PROM_ASSERT(self != NULL); if (self->limit) { - prom_free((void *) self->limit); + prom_free((void *)self->limit); self->limit = NULL; } if (self->units) { - prom_free((void *) self->units); + prom_free((void *)self->units); self->units = NULL; } self->soft = 0; @@ -139,11 +132,11 @@ int prom_process_limits_current_row_destroy(prom_process_limits_current_row_t *s //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // prom_process_limits_file_t -prom_process_limits_file_t* prom_process_limits_file_new(const char *path) { +prom_process_limits_file_t *prom_process_limits_file_new(const char *path) { if (path) { return prom_procfs_buf_new(path); } else { - int pid = (int) getpid(); + int pid = (int)getpid(); char path[255]; sprintf(path, "/proc/%d/limits", pid); return prom_procfs_buf_new(path); @@ -161,7 +154,7 @@ int prom_process_limits_file_destroy(prom_process_limits_file_t *self) { } static void prom_process_limits_file_free_map_item_fn(void *gen) { - prom_process_limits_row_t *row = (prom_process_limits_row_t *) gen; + prom_process_limits_row_t *row = (prom_process_limits_row_t *)gen; prom_process_limits_row_destroy(row); row = NULL; } @@ -184,16 +177,11 @@ static void prom_process_limits_file_free_map_item_fn(void *gen) { * | "q" | "r" | "s" | "t" | "u" | "v" | "w" * | "x" | "y" | "z" ; * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; - * data_line = limit , space, space, { " " }, soft_limit, " ", " ", { " " }, hard_limit, " ", " ", { " " }, { units }, { space_char }, "\n" ; - * space_char = " " | "\t" ; - * limit = { word_and_space } , word ; - * word_and_space = word, " " ; - * word = letter, { letter } ; - * soft_limit = ( digit, { digit } ) | "unlimited" ; - * hard_limit = soft_limit ; - * units = word ; + * data_line = limit , space, space, { " " }, soft_limit, " ", " ", { " " }, hard_limit, " ", " ", { " " }, { units }, { + * space_char }, "\n" ; space_char = " " | "\t" ; limit = { word_and_space } , word ; word_and_space = word, " " ; word + * = letter, { letter } ; soft_limit = ( digit, { digit } ) | "unlimited" ; hard_limit = soft_limit ; units = word ; */ -prom_map_t* prom_process_limits(prom_process_limits_file_t *f) { +prom_map_t *prom_process_limits(prom_process_limits_file_t *f) { prom_map_t *m = prom_map_new(); if (m == NULL) return NULL; int r = 0; @@ -219,10 +207,8 @@ prom_map_t* prom_process_limits(prom_process_limits_file_t *f) { return m; } -bool prom_process_limits_rdp_file(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_file(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { if (!prom_process_limits_rdp_first_line(f, map, current_row)) return false; while (f->index < f->size - 1) { @@ -232,11 +218,10 @@ bool prom_process_limits_rdp_file(prom_process_limits_file_t *f, return true; } -bool prom_process_limits_rdp_first_line(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ - while(prom_process_limits_rdp_character(f, map, current_row)){} +bool prom_process_limits_rdp_first_line(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { + while (prom_process_limits_rdp_character(f, map, current_row)) { + } if (f->buf[f->index] == '\n') { f->index++; return true; @@ -244,11 +229,8 @@ bool prom_process_limits_rdp_first_line(prom_process_limits_file_t *f, return false; } - -bool prom_process_limits_rdp_character(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_character(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { if (prom_process_limits_rdp_letter(f, map, current_row)) return true; if (prom_process_limits_rdp_digit(f, map, current_row)) return true; if (f->buf[f->index] == ' ' && f->buf[f->index] < f->size - 1) { @@ -258,17 +240,14 @@ bool prom_process_limits_rdp_character(prom_process_limits_file_t *f, return false; } -bool prom_process_limits_rdp_letter(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_letter(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { if (f->index >= f->size - 1) return false; unsigned int size = sizeof(PROM_PROCESS_LIMITS_RDP_LETTERS); for (int i = 0; i < size; i++) { int letter = PROM_PROCESS_LIMITS_RDP_LETTERS[i]; int in_buff = f->buf[f->index]; if (letter == in_buff) { - f->index++; return true; } @@ -276,10 +255,8 @@ bool prom_process_limits_rdp_letter(prom_process_limits_file_t *f, return false; } -bool prom_process_limits_rdp_digit(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_digit(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { if (f->index >= f->size - 1) return false; unsigned int size = sizeof(PROM_PROCESS_LIMITS_RDP_DIGITS); for (int i = 0; i < size; i++) { @@ -293,10 +270,8 @@ bool prom_process_limits_rdp_digit(prom_process_limits_file_t *f, return false; } -bool prom_process_limits_rdp_data_line(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_data_line(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { // Process and parse data line, loading relevant data into the current_row if (!prom_process_limits_rdp_limit(f, map, current_row)) return false; prom_process_limits_rdp_next_token(f); @@ -307,10 +282,10 @@ bool prom_process_limits_rdp_data_line(prom_process_limits_file_t *f, prom_process_limits_rdp_units(f, map, current_row); // Load data from the current row into the map - const char *limit = (const char *) current_row->limit; + const char *limit = (const char *)current_row->limit; int soft = current_row->soft; int hard = current_row->hard; - const char *units = (const char *) current_row->units; + const char *units = (const char *)current_row->units; prom_process_limits_row_t *row = prom_process_limits_row_new(limit, soft, hard, units); prom_map_set(map, limit, row); prom_process_limits_current_row_clear(current_row); @@ -318,16 +293,13 @@ bool prom_process_limits_rdp_data_line(prom_process_limits_file_t *f, // Progress to the next token prom_process_limits_rdp_next_token(f); return true; - } /** * @brief EBNF: space_char = " " | "\t" ; */ -bool prom_process_limits_rdp_space_char(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_space_char(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { char c = f->buf[f->index]; if (c == ' ' || c == '\t') { f->index++; @@ -339,20 +311,19 @@ bool prom_process_limits_rdp_space_char(prom_process_limits_file_t *f, /** * @brief EBNF: limit = { word_and_space } , word ; */ -bool prom_process_limits_rdp_limit(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_limit(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { size_t current_index = f->index; - while(prom_process_limits_rdp_word_and_space(f, map, current_row)) {} + while (prom_process_limits_rdp_word_and_space(f, map, current_row)) { + } if (prom_process_limits_rdp_word(f, map, current_row)) { - size_t size = f->index - current_index + 1; // Add one for \0 + size_t size = f->index - current_index + 1; // Add one for \0 char limit[size]; for (int i = 0; i < size - 1; i++) { - limit[i] = f->buf[current_index+i]; + limit[i] = f->buf[current_index + i]; } - limit[size-1] = '\0'; + limit[size - 1] = '\0'; prom_process_limits_current_row_set_limit(current_row, limit); return true; } @@ -362,14 +333,12 @@ bool prom_process_limits_rdp_limit(prom_process_limits_file_t *f, /** * @brief EBNF: word_and_space = letter, { letter }, " " ; */ -bool prom_process_limits_rdp_word_and_space(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_word_and_space(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { size_t current_index = f->index; if (prom_process_limits_rdp_word(f, map, current_row) && f->buf[f->index] == ' ') { f->index++; - if (f->index+1 < f->size && f->buf[f->index+1] != ' ' && f->buf[f->index+1] != '\t') { + if (f->index + 1 < f->size && f->buf[f->index + 1] != ' ' && f->buf[f->index + 1] != '\t') { return true; } } @@ -377,83 +346,73 @@ bool prom_process_limits_rdp_word_and_space(prom_process_limits_file_t *f, return false; } -bool prom_process_limits_rdp_word(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_word(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { size_t original_index = f->index; - while(prom_process_limits_rdp_letter(f, map, current_row)) {} + while (prom_process_limits_rdp_letter(f, map, current_row)) { + } return (f->index - original_index) > 0; } -static bool prom_process_limits_rdp_generic_limit(prom_process_limits_file_t *f, - prom_map_t *map, +static bool prom_process_limits_rdp_generic_limit(prom_process_limits_file_t *f, prom_map_t *map, prom_process_limits_current_row_t *current_row, - prom_process_limit_rdp_limit_type_t type) -{ + prom_process_limit_rdp_limit_type_t type) { size_t current_index = f->index; int value = 0; if (prom_process_limits_rdp_match(f, PROM_PROCESS_LIMITS_RDP_UNLIMITED)) { value = -1; } else { - while(prom_process_limits_rdp_digit(f, map, current_row)){} + while (prom_process_limits_rdp_digit(f, map, current_row)) { + } size_t num_digits = f->index - current_index + 1; if (num_digits <= 0) return false; - char buf[num_digits+1]; + char buf[num_digits + 1]; for (size_t i = 0; i < num_digits - 1; i++) { - buf[i] = f->buf[current_index+i]; + buf[i] = f->buf[current_index + i]; } - buf[num_digits-1] = '\0'; + buf[num_digits - 1] = '\0'; value = atoi(buf); f->index += num_digits; } switch (type) { - case PROM_PROCESS_LIMITS_RDP_SOFT: - current_row->soft = value; - case PROM_PROCESS_LIMITS_RDP_HARD: - current_row->hard = value; + case PROM_PROCESS_LIMITS_RDP_SOFT: + current_row->soft = value; + case PROM_PROCESS_LIMITS_RDP_HARD: + current_row->hard = value; } return true; } - -bool prom_process_limits_rdp_soft_limit(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ - return prom_process_limits_rdp_generic_limit(f, map, current_row, PROM_PROCESS_LIMITS_RDP_SOFT); +bool prom_process_limits_rdp_soft_limit(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { + return prom_process_limits_rdp_generic_limit(f, map, current_row, PROM_PROCESS_LIMITS_RDP_SOFT); } -bool prom_process_limits_rdp_hard_limit(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_hard_limit(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { return prom_process_limits_rdp_generic_limit(f, map, current_row, PROM_PROCESS_LIMITS_RDP_HARD); } -bool prom_process_limits_rdp_units(prom_process_limits_file_t *f, - prom_map_t *map, - prom_process_limits_current_row_t *current_row) -{ +bool prom_process_limits_rdp_units(prom_process_limits_file_t *f, prom_map_t *map, + prom_process_limits_current_row_t *current_row) { size_t current_index = f->index; if (prom_process_limits_rdp_word(f, map, current_row)) { size_t num_chars = f->index - current_index + 1; char buf[num_chars]; for (size_t i = 0; i < num_chars - 1; i++) { - buf[i] = f->buf[current_index+i]; + buf[i] = f->buf[current_index + i]; } - buf[num_chars-1] = '\0'; + buf[num_chars - 1] = '\0'; prom_process_limits_current_row_set_units(current_row, buf); return true; } return false; } - int prom_process_limits_rdp_next_token(prom_process_limits_file_t *f) { while (f->buf[f->index] == ' ' || f->buf[f->index] == '\n' || f->buf[f->index] == '\t') { f->index++; @@ -478,16 +437,9 @@ bool prom_process_limits_rdp_match(prom_process_limits_file_t *f, const char *to * @brief Initializes each gauge metric found in prom_process_t.h */ int prom_process_limits_init(void) { - prom_process_max_fds = prom_gauge_new( - "process_max_fds", - "Maximum number of open file descriptors.", - 0, NULL - ); + prom_process_max_fds = prom_gauge_new("process_max_fds", "Maximum number of open file descriptors.", 0, NULL); prom_process_virtual_memory_max_bytes = prom_gauge_new( - "process_virtual_memory_max_bytes", - "Maximum amount of virtual memory available in bytes.", - 0, NULL - ); + "process_virtual_memory_max_bytes", "Maximum amount of virtual memory available in bytes.", 0, NULL); return 0; } diff --git a/prom/src/prom_process_limits_i.h b/prom/src/prom_process_limits_i.h index 80142d8..5a11eff 100644 --- a/prom/src/prom_process_limits_i.h +++ b/prom/src/prom_process_limits_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,42 +27,49 @@ */ int prom_process_init(void); -prom_process_limits_row_t* prom_process_limits_row_new(const char *limit, - const int soft, - const int hard, +prom_process_limits_row_t *prom_process_limits_row_new(const char *limit, const int soft, const int hard, const char *units); int prom_process_limits_row_destroy(prom_process_limits_row_t *self); - -prom_process_limits_current_row_t* prom_process_limits_current_row_new(void); +prom_process_limits_current_row_t *prom_process_limits_current_row_new(void); int prom_process_limits_current_row_set_limit(prom_process_limits_current_row_t *self, char *limit); int prom_process_limits_current_row_set_units(prom_process_limits_current_row_t *self, char *units); int prom_process_limits_current_row_clear(prom_process_limits_current_row_t *self); int prom_process_limits_current_row_destroy(prom_process_limits_current_row_t *self); - -prom_process_limits_file_t* prom_process_limits_file_new(const char *path); +prom_process_limits_file_t *prom_process_limits_file_new(const char *path); int prom_process_limits_file_destroy(prom_process_limits_file_t *self); - -prom_map_t* prom_process_limits(prom_process_limits_file_t *f); -bool prom_process_limits_rdp_file(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_first_line(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_character(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_letter(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_digit(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_data_line(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_limit(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_word_and_space(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_word(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_soft_limit(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row);; -bool prom_process_limits_rdp_hard_limit(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); -bool prom_process_limits_rdp_units(prom_process_limits_file_t *f, prom_map_t *data, prom_process_limits_current_row_t *current_row); - +prom_map_t *prom_process_limits(prom_process_limits_file_t *f); +bool prom_process_limits_rdp_file(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_first_line(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_character(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_letter(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_digit(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_data_line(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_limit(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_word_and_space(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_word(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_soft_limit(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +; +bool prom_process_limits_rdp_hard_limit(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); +bool prom_process_limits_rdp_units(prom_process_limits_file_t *f, prom_map_t *data, + prom_process_limits_current_row_t *current_row); int prom_process_limits_rdp_next_token(prom_process_limits_file_t *f); bool prom_process_limits_rdp_match(prom_process_limits_file_t *f, const char *token); int prom_process_limits_init(void); -#endif // PROM_PROCESS_I_H \ No newline at end of file +#endif // PROM_PROCESS_I_H diff --git a/prom/src/prom_process_limits_t.h b/prom/src/prom_process_limits_t.h index b18253d..272c7e5 100644 --- a/prom/src/prom_process_limits_t.h +++ b/prom/src/prom_process_limits_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,27 +20,25 @@ #include "prom_gauge.h" #include "prom_procfs_t.h" - extern prom_gauge_t *prom_process_open_fds; extern prom_gauge_t *prom_process_max_fds; extern prom_gauge_t *prom_process_virtual_memory_max_bytes; extern prom_gauge_t *prom_process_resident_memory_bytes; - typedef struct prom_process_limits_row { - const char *limit; /**< Pointer to a string */ - int soft; /**< Soft value */ - int hard; /**< Hard value */ - const char *units; /**< Units */ + const char *limit; /**< Pointer to a string */ + int soft; /**< Soft value */ + int hard; /**< Hard value */ + const char *units; /**< Units */ } prom_process_limits_row_t; typedef struct prom_process_limits_current_row { - char *limit; /**< Pointer to a string */ - int soft; /**< Soft value */ - int hard; /**< Hard value */ - char *units; /**< Units */ + char *limit; /**< Pointer to a string */ + int soft; /**< Soft value */ + int hard; /**< Hard value */ + char *units; /**< Units */ } prom_process_limits_current_row_t; typedef prom_procfs_buf_t prom_process_limits_file_t; -#endif // PROM_PROCESS_T_H +#endif // PROM_PROCESS_T_H diff --git a/prom/src/prom_process_stat.c b/prom/src/prom_process_stat.c index 7a1833c..438fdc1 100644 --- a/prom/src/prom_process_stat.c +++ b/prom/src/prom_process_stat.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,8 @@ */ #include -#include - #include - +#include // Public #include "prom_alloc.h" @@ -32,11 +30,11 @@ prom_gauge_t *prom_process_cpu_seconds_total; prom_gauge_t *prom_process_virtual_memory_bytes; prom_gauge_t *prom_process_start_time_seconds; -prom_process_stat_file_t* prom_process_stat_file_new(const char *path) { +prom_process_stat_file_t *prom_process_stat_file_new(const char *path) { if (path) { return prom_procfs_buf_new(path); } else { - int pid = (int) getpid(); + int pid = (int)getpid(); char path[50]; sprintf(path, "/proc/%d/stat", pid); return prom_procfs_buf_new(path); @@ -52,116 +50,115 @@ int prom_process_stat_file_destroy(prom_process_stat_file_t *self) { return r; } -prom_process_stat_t* prom_process_stat_new(prom_process_stat_file_t *stat_f) { - prom_process_stat_t *self = (prom_process_stat_t*) prom_malloc(sizeof(prom_process_stat_t)); +prom_process_stat_t *prom_process_stat_new(prom_process_stat_file_t *stat_f) { + prom_process_stat_t *self = (prom_process_stat_t *)prom_malloc(sizeof(prom_process_stat_t)); self->comm = prom_malloc(128); - sscanf( - (const char *) stat_f->buf, - "%d " // (1) pid %d - "%s " // (2) comm %s - "%c " // (3) state %c - "%d " // (4) ppid %d - "%d " // (5) pgrp %d - "%d " // (6) session %d - "%d " // (7) tty_nr %d - "%d " // (8) tpgid %d - "%u " // (9) flags %u - "%lu " // (10) minflt %lu - "%lu " // (11) cminflt %lu - "%lu " // (12) majflt %lu - "%lu " // (13) cmajflt %lu - "%lu " // (14) utime %lu - "%lu " // (15) stime %lu - "%ld " // (16) cutime %ld - "%ld " // (17) cstime %ld - "%ld " // (18) priority %ld - "%ld " // (19) nice %ld - "%ld " // (20) num_threads %ld - "%ld " // (21) itrealvalue %ld - "%llu " // (22) starttime %llu - "%lu " // (23) vsize %lu - "%ld " // (24) rss %ld - "%lu " // (25) rsslim %lu - "%lu " // (26) startcode %lu [PT] - "%lu " // (27) endcode %lu [PT] - "%lu " // (28) startstack %lu [PT] - "%lu " // (29) kstkesp %lu [PT] - "%lu " // (30) kstkeip %lu [PT] - "%lu " // (31) signal %lu - "%lu " // (32) blocked %lu - "%lu " // (33) sigignore %lu - "%lu " // (34) sigcatch %lu - "%lu " // (35) wchan %lu [PT] - "%lu " // (36) nswap %lu - "%lu " // (37) cnswap %lu - "%d " // (38) exit_signal %d (since Linux 2.1.22) - "%d " // (39) processor %d (since Linux 2.2.8) - "%u " // (40) rt_priority %u (since Linux 2.5.19) - "%u " // (41) policy %u (since Linux 2.5.19) - "%llu " // (42) delayacct_blkio_ticks %llu (since Linux 2.6.18) - "%lu " // (43) guest_time %lu (since Linux 2.6.24) - "%ld " // (44) cguest_time %ld (since Linux 2.6.24) - "%lu " // (45) start_data %lu (since Linux 3.3) [PT] - "%lu " // (46) end_data %lu (since Linux 3.3) [PT] - "%lu " // (47) start_brk %lu (since Linux 3.3) [PT] - "%lu " // (48) arg_start %lu (since Linux 3.5) [PT] - "%lu " // (49) arg_end %lu (since Linux 3.5) [PT] - "%lu " // (50) env_start %lu (since Linux 3.5) [PT] - "%lu " // (51) env_end %lu (since Linux 3.5) [PT] - "%d ", // (52) exit_code %d (since Linux 3.5) [PT] - &self->pid, // (1) pid %d - self->comm, // (2) comm %s - &self->state, // (3) state %c - &self->ppid, // (4) ppid %d - &self->pgrp, // (5) pgrp %d - &self->session, // (6) session %d - &self->tty_nr, // (7) tty_nr %d - &self->tpgid, // (8) tpgid %d - &self->flags, // (9) flags %u - &self->minflt, // (10) minflt %lu - &self->cminflt, // (11) cminflt %lu - &self->majflt, // (12) majflt %lu - &self->cmajflt, // (13) cmajflt %lu - &self->utime, // (14) utime %lu - &self->stime, // (15) stime %lu - &self->cutime, // (16) cutime %ld - &self->cstime, // (17) cstime %ld - &self->priority, // (18) priority %ld - &self->nice, // (19) nice %ld - &self->num_threads, // (20) num_threads %ld - &self->itrealvalue, // (21) itrealvalue %ld - &self->starttime, // (22) starttime %llu - &self->vsize, // (23) vsize %lu - &self->rss, // (24) rss %ld - &self->rsslim, // (25) rsslim %lu - &self->startcode, // (26) startcode %lu [PT] - &self->endcode, // (27) endcode %lu [PT] - &self->startstack, // (28) startstack %lu [PT] - &self->kstkesp, // (29) kstkesp %lu [PT] - &self->kstkeip, // (30) kstkeip %lu [PT] - &self->signal, // (31) signal %lu - &self->blocked, // (32) blocked %lu - &self->sigignore, // (33) sigignore %lu - &self->sigcatch, // (34) sigcatch %lu - &self->wchan, // (35) wchan %lu [PT] - &self->nswap, // (36) nswap %lu - &self->cnswap, // (37) cnswap %lu - &self->exit_signal, // (38) exit_signal %d (since Linux 2.1.22) - &self->processor, // (39) processor %d (since Linux 2.2.8) - &self->rt_priority, // (40) rt_priority %u (since Linux 2.5.19) - &self->policy, // (41) policy %u (since Linux 2.5.19) - &self->delayacct_blkio_ticks, // (42) delayacct_blkio_ticks %llu (since Linux 2.6.18) - &self->guest_time, // (43) guest_time %lu (since Linux 2.6.24) - &self->cguest_time, // (44) cguest_time %ld (since Linux 2.6.24) - &self->start_data, // (45) start_data %lu (since Linux 3.3) [PT] - &self->end_data, // (46) end_data %lu (since Linux 3.3) [PT] - &self->start_brk, // (47) start_brk %lu (since Linux 3.3) [PT] - &self->arg_start, // (48) arg_start %lu (since Linux 3.5) [PT] - &self->arg_end, // (49) arg_end %lu (since Linux 3.5) [PT] - &self->env_start, // (50) env_start %lu (since Linux 3.5) [PT] - &self->env_end, // (51) env_end %lu (since Linux 3.5) [PT] - &self->exit_code // (52) exit_code %d (since Linux 3.5) [PT] + sscanf((const char *)stat_f->buf, + "%d " // (1) pid %d + "%s " // (2) comm %s + "%c " // (3) state %c + "%d " // (4) ppid %d + "%d " // (5) pgrp %d + "%d " // (6) session %d + "%d " // (7) tty_nr %d + "%d " // (8) tpgid %d + "%u " // (9) flags %u + "%lu " // (10) minflt %lu + "%lu " // (11) cminflt %lu + "%lu " // (12) majflt %lu + "%lu " // (13) cmajflt %lu + "%lu " // (14) utime %lu + "%lu " // (15) stime %lu + "%ld " // (16) cutime %ld + "%ld " // (17) cstime %ld + "%ld " // (18) priority %ld + "%ld " // (19) nice %ld + "%ld " // (20) num_threads %ld + "%ld " // (21) itrealvalue %ld + "%llu " // (22) starttime %llu + "%lu " // (23) vsize %lu + "%ld " // (24) rss %ld + "%lu " // (25) rsslim %lu + "%lu " // (26) startcode %lu [PT] + "%lu " // (27) endcode %lu [PT] + "%lu " // (28) startstack %lu [PT] + "%lu " // (29) kstkesp %lu [PT] + "%lu " // (30) kstkeip %lu [PT] + "%lu " // (31) signal %lu + "%lu " // (32) blocked %lu + "%lu " // (33) sigignore %lu + "%lu " // (34) sigcatch %lu + "%lu " // (35) wchan %lu [PT] + "%lu " // (36) nswap %lu + "%lu " // (37) cnswap %lu + "%d " // (38) exit_signal %d (since Linux 2.1.22) + "%d " // (39) processor %d (since Linux 2.2.8) + "%u " // (40) rt_priority %u (since Linux 2.5.19) + "%u " // (41) policy %u (since Linux 2.5.19) + "%llu " // (42) delayacct_blkio_ticks %llu (since Linux 2.6.18) + "%lu " // (43) guest_time %lu (since Linux 2.6.24) + "%ld " // (44) cguest_time %ld (since Linux 2.6.24) + "%lu " // (45) start_data %lu (since Linux 3.3) [PT] + "%lu " // (46) end_data %lu (since Linux 3.3) [PT] + "%lu " // (47) start_brk %lu (since Linux 3.3) [PT] + "%lu " // (48) arg_start %lu (since Linux 3.5) [PT] + "%lu " // (49) arg_end %lu (since Linux 3.5) [PT] + "%lu " // (50) env_start %lu (since Linux 3.5) [PT] + "%lu " // (51) env_end %lu (since Linux 3.5) [PT] + "%d ", // (52) exit_code %d (since Linux 3.5) [PT] + &self->pid, // (1) pid %d + self->comm, // (2) comm %s + &self->state, // (3) state %c + &self->ppid, // (4) ppid %d + &self->pgrp, // (5) pgrp %d + &self->session, // (6) session %d + &self->tty_nr, // (7) tty_nr %d + &self->tpgid, // (8) tpgid %d + &self->flags, // (9) flags %u + &self->minflt, // (10) minflt %lu + &self->cminflt, // (11) cminflt %lu + &self->majflt, // (12) majflt %lu + &self->cmajflt, // (13) cmajflt %lu + &self->utime, // (14) utime %lu + &self->stime, // (15) stime %lu + &self->cutime, // (16) cutime %ld + &self->cstime, // (17) cstime %ld + &self->priority, // (18) priority %ld + &self->nice, // (19) nice %ld + &self->num_threads, // (20) num_threads %ld + &self->itrealvalue, // (21) itrealvalue %ld + &self->starttime, // (22) starttime %llu + &self->vsize, // (23) vsize %lu + &self->rss, // (24) rss %ld + &self->rsslim, // (25) rsslim %lu + &self->startcode, // (26) startcode %lu [PT] + &self->endcode, // (27) endcode %lu [PT] + &self->startstack, // (28) startstack %lu [PT] + &self->kstkesp, // (29) kstkesp %lu [PT] + &self->kstkeip, // (30) kstkeip %lu [PT] + &self->signal, // (31) signal %lu + &self->blocked, // (32) blocked %lu + &self->sigignore, // (33) sigignore %lu + &self->sigcatch, // (34) sigcatch %lu + &self->wchan, // (35) wchan %lu [PT] + &self->nswap, // (36) nswap %lu + &self->cnswap, // (37) cnswap %lu + &self->exit_signal, // (38) exit_signal %d (since Linux 2.1.22) + &self->processor, // (39) processor %d (since Linux 2.2.8) + &self->rt_priority, // (40) rt_priority %u (since Linux 2.5.19) + &self->policy, // (41) policy %u (since Linux 2.5.19) + &self->delayacct_blkio_ticks, // (42) delayacct_blkio_ticks %llu (since Linux 2.6.18) + &self->guest_time, // (43) guest_time %lu (since Linux 2.6.24) + &self->cguest_time, // (44) cguest_time %ld (since Linux 2.6.24) + &self->start_data, // (45) start_data %lu (since Linux 3.3) [PT] + &self->end_data, // (46) end_data %lu (since Linux 3.3) [PT] + &self->start_brk, // (47) start_brk %lu (since Linux 3.3) [PT] + &self->arg_start, // (48) arg_start %lu (since Linux 3.5) [PT] + &self->arg_end, // (49) arg_end %lu (since Linux 3.5) [PT] + &self->env_start, // (50) env_start %lu (since Linux 3.5) [PT] + &self->env_end, // (51) env_end %lu (since Linux 3.5) [PT] + &self->exit_code // (52) exit_code %d (since Linux 3.5) [PT] ); return self; } @@ -169,8 +166,8 @@ prom_process_stat_t* prom_process_stat_new(prom_process_stat_file_t *stat_f) { int prom_process_stat_destroy(prom_process_stat_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return 0; - prom_free((void *) self->comm); - prom_free((void *) self); + prom_free((void *)self->comm); + prom_free((void *)self); self = NULL; return 0; } @@ -180,23 +177,14 @@ int prom_process_stat_destroy(prom_process_stat_t *self) { */ int prom_process_stats_init(void) { // /proc/[pid]stat cutime + cstime / 100 - prom_process_cpu_seconds_total = prom_gauge_new( - "process_cpu_seconds_total", - "Total user and system CPU time spent in seconds.", - 0, NULL - ); + prom_process_cpu_seconds_total = + prom_gauge_new("process_cpu_seconds_total", "Total user and system CPU time spent in seconds.", 0, NULL); // /proc/[pid]/stat Field 23 - prom_process_virtual_memory_bytes = prom_gauge_new( - "process_virtual_memory_bytes", - "Virtual memory size in bytes.", - 0, NULL - ); + prom_process_virtual_memory_bytes = + prom_gauge_new("process_virtual_memory_bytes", "Virtual memory size in bytes.", 0, NULL); - prom_process_start_time_seconds = prom_gauge_new( - "process_start_time_seconds", - "Start time of the process since unix epoch in seconds.", - 0, NULL - ); + prom_process_start_time_seconds = + prom_gauge_new("process_start_time_seconds", "Start time of the process since unix epoch in seconds.", 0, NULL); return 0; } diff --git a/prom/src/prom_process_stat_i.h b/prom/src/prom_process_stat_i.h index f98c745..7f3b612 100644 --- a/prom/src/prom_process_stat_i.h +++ b/prom/src/prom_process_stat_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,16 +14,15 @@ * limitations under the License. */ - #ifndef PROM_PROCESS_STATS_I_H #define PROM_PROCESS_STATS_I_H #include "prom_process_stat_t.h" -prom_process_stat_file_t* prom_process_stat_file_new(const char *path); +prom_process_stat_file_t *prom_process_stat_file_new(const char *path); int prom_process_stat_file_destroy(prom_process_stat_file_t *self); -prom_process_stat_t* prom_process_stat_new(prom_process_stat_file_t *stat_f); +prom_process_stat_t *prom_process_stat_new(prom_process_stat_file_t *stat_f); int prom_process_stat_destroy(prom_process_stat_t *self); int prom_process_stats_init(void); -#endif // PROM_PROCESS_STATS_I_H \ No newline at end of file +#endif // PROM_PROCESS_STATS_I_H diff --git a/prom/src/prom_process_stat_t.h b/prom/src/prom_process_stat_t.h index a26ecda..3283609 100644 --- a/prom/src/prom_process_stat_t.h +++ b/prom/src/prom_process_stat_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,12 +14,10 @@ * limitations under the License. */ - #ifndef PROM_PROCESS_STATS_T_H #define PROM_PROCESS_STATS_T_H #include "prom_gauge.h" - #include "prom_procfs_t.h" extern prom_gauge_t *prom_process_cpu_seconds_total; @@ -30,60 +28,60 @@ extern prom_gauge_t *prom_process_start_time_seconds; * @brief Refer to man proc and search for /proc/[pid]/stat */ typedef struct prom_process_stat { - int pid; // (1) pid %d - char *comm; // (2) comm %s - char state; // (3) state %c - int ppid; // (4) ppid %d - int pgrp; // (5) pgrp %d - int session; // (6) session %d - int tty_nr; // (7) tty_nr %d - int tpgid; // (8) tpgid %d - unsigned flags; // (9) flags %u - unsigned long minflt; // (10) minflt %lu - unsigned long cminflt; // (11) cminflt %lu - unsigned long majflt; // (12) majflt %lu - unsigned long cmajflt; // (13) cmajflt %lu - unsigned long utime; // (14) utime %lu - unsigned long stime; // (15) stime %lu - long int cutime; // (16) cutime %ld - long int cstime; // (17) cstime %ld - long int priority; // (18) priority %ld - long int nice; // (19) nice %ld - long int num_threads; // (20) num_threads %ld - long int itrealvalue; // (21) itrealvalue %ld - unsigned long long starttime; // (22) starttime %llu - unsigned long vsize; // (23) vsize %lu - long int rss; // (24) rss %ld - unsigned long rsslim; // (25) rsslim %lu - unsigned long startcode; // (26) startcode %lu [PT] - unsigned long endcode; // (27) endcode %lu [PT] - unsigned long startstack; // (28) startstack %lu [PT] - unsigned long kstkesp; // (29) kstkesp %lu [PT] - unsigned long kstkeip; // (30) kstkeip %lu [PT] - unsigned long signal; // (31) signal %lu - unsigned long blocked; // (32) blocked %lu - unsigned long sigignore; // (33) sigignore %lu - unsigned long sigcatch; // (34) sigcatch %lu - unsigned long wchan; // (35) wchan %lu [PT] - unsigned long nswap; // (36) nswap %lu - unsigned long cnswap; // (37) cnswap %lu - int exit_signal; // (38) exit_signal %d (since Linux 2.1.22) - int processor; // (39) processor %d (since Linux 2.2.8) - unsigned rt_priority; // (40) rt_priority %u (since Linux 2.5.19) - unsigned policy; // (41) policy %u (since Linux 2.5.19) - unsigned long long delayacct_blkio_ticks; // (42) delayacct_blkio_ticks - unsigned long guest_time; // (43) guest_time %lu (since Linux 2.6.24) - long int cguest_time; // (44) cguest_time %ld (since Linux 2.6.24) - unsigned long start_data; // (45) start_data %lu (since Linux 3.3) [PT] - unsigned long end_data; // (46) end_data %lu (since Linux 3.3) [PT] - unsigned long start_brk; // (47) start_brk %lu (since Linux 3.3) [PT] - unsigned long arg_start; // (48) arg_start %lu (since Linux 3.5) [PT] - unsigned long arg_end; // (49) arg_end %lu (since Linux 3.5) [PT] - unsigned long env_start; // (50) env_start %lu (since Linux 3.5) [PT] - unsigned long env_end; // (51) env_end %lu (since Linux 3.5) [PT] - int exit_code; // (52) exit_code %d (since Linux 3.5) [PT] + int pid; // (1) pid %d + char *comm; // (2) comm %s + char state; // (3) state %c + int ppid; // (4) ppid %d + int pgrp; // (5) pgrp %d + int session; // (6) session %d + int tty_nr; // (7) tty_nr %d + int tpgid; // (8) tpgid %d + unsigned flags; // (9) flags %u + unsigned long minflt; // (10) minflt %lu + unsigned long cminflt; // (11) cminflt %lu + unsigned long majflt; // (12) majflt %lu + unsigned long cmajflt; // (13) cmajflt %lu + unsigned long utime; // (14) utime %lu + unsigned long stime; // (15) stime %lu + long int cutime; // (16) cutime %ld + long int cstime; // (17) cstime %ld + long int priority; // (18) priority %ld + long int nice; // (19) nice %ld + long int num_threads; // (20) num_threads %ld + long int itrealvalue; // (21) itrealvalue %ld + unsigned long long starttime; // (22) starttime %llu + unsigned long vsize; // (23) vsize %lu + long int rss; // (24) rss %ld + unsigned long rsslim; // (25) rsslim %lu + unsigned long startcode; // (26) startcode %lu [PT] + unsigned long endcode; // (27) endcode %lu [PT] + unsigned long startstack; // (28) startstack %lu [PT] + unsigned long kstkesp; // (29) kstkesp %lu [PT] + unsigned long kstkeip; // (30) kstkeip %lu [PT] + unsigned long signal; // (31) signal %lu + unsigned long blocked; // (32) blocked %lu + unsigned long sigignore; // (33) sigignore %lu + unsigned long sigcatch; // (34) sigcatch %lu + unsigned long wchan; // (35) wchan %lu [PT] + unsigned long nswap; // (36) nswap %lu + unsigned long cnswap; // (37) cnswap %lu + int exit_signal; // (38) exit_signal %d (since Linux 2.1.22) + int processor; // (39) processor %d (since Linux 2.2.8) + unsigned rt_priority; // (40) rt_priority %u (since Linux 2.5.19) + unsigned policy; // (41) policy %u (since Linux 2.5.19) + unsigned long long delayacct_blkio_ticks; // (42) delayacct_blkio_ticks + unsigned long guest_time; // (43) guest_time %lu (since Linux 2.6.24) + long int cguest_time; // (44) cguest_time %ld (since Linux 2.6.24) + unsigned long start_data; // (45) start_data %lu (since Linux 3.3) [PT] + unsigned long end_data; // (46) end_data %lu (since Linux 3.3) [PT] + unsigned long start_brk; // (47) start_brk %lu (since Linux 3.3) [PT] + unsigned long arg_start; // (48) arg_start %lu (since Linux 3.5) [PT] + unsigned long arg_end; // (49) arg_end %lu (since Linux 3.5) [PT] + unsigned long env_start; // (50) env_start %lu (since Linux 3.5) [PT] + unsigned long env_end; // (51) env_end %lu (since Linux 3.5) [PT] + int exit_code; // (52) exit_code %d (since Linux 3.5) [PT] } prom_process_stat_t; typedef prom_procfs_buf_t prom_process_stat_file_t; -#endif // PROM_PROCESS_STATS_T_H +#endif // PROM_PROCESS_STATS_T_H diff --git a/prom/src/prom_procfs.c b/prom/src/prom_procfs.c index 1bea1a3..f9d686a 100644 --- a/prom/src/prom_procfs.c +++ b/prom/src/prom_procfs.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,16 +28,15 @@ #include "prom_log.h" #include "prom_procfs_i.h" - static int prom_procfs_ensure_buf_size(prom_procfs_buf_t *self) { PROM_ASSERT(self != NULL); - if (self->allocated >= self->size+1) return 0; - while (self->allocated < self->size+1) self->allocated <<= 1; - self->buf = (char *) prom_realloc(self->buf, self->allocated); + if (self->allocated >= self->size + 1) return 0; + while (self->allocated < self->size + 1) self->allocated <<= 1; + self->buf = (char *)prom_realloc(self->buf, self->allocated); return 0; } -prom_procfs_buf_t* prom_procfs_buf_new(const char *path) { +prom_procfs_buf_t *prom_procfs_buf_new(const char *path) { int r = 0; FILE *f = fopen(path, "r"); @@ -49,12 +48,12 @@ prom_procfs_buf_t* prom_procfs_buf_new(const char *path) { return NULL; } - #define PROM_PROCFS_BUF_NEW_HANDLE_F_CLOSE(f) \ - r = fclose(f); \ - if (r) { \ - strerror_r(errno, errbuf, 100); \ - PROM_LOG(errbuf); \ - } +#define PROM_PROCFS_BUF_NEW_HANDLE_F_CLOSE(f) \ + r = fclose(f); \ + if (r) { \ + strerror_r(errno, errbuf, 100); \ + PROM_LOG(errbuf); \ + } unsigned short int initial_size = 32; prom_procfs_buf_t *self = prom_malloc(sizeof(prom_procfs_buf_t)); @@ -63,11 +62,7 @@ prom_procfs_buf_t* prom_procfs_buf_new(const char *path) { self->index = 0; self->allocated = initial_size; - for ( - int current_char = getc(f), i = 0; - current_char != EOF; - current_char = getc(f), i++ - ) { + for (int current_char = getc(f), i = 0; current_char != EOF; current_char = getc(f), i++) { r = prom_procfs_ensure_buf_size(self); if (r) { prom_procfs_buf_destroy(self); diff --git a/prom/src/prom_procfs_i.h b/prom/src/prom_procfs_i.h index 12c79ad..53a4ddb 100644 --- a/prom/src/prom_procfs_i.h +++ b/prom/src/prom_procfs_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,9 +19,8 @@ #include "prom_procfs_t.h" -prom_procfs_buf_t* prom_procfs_buf_new(const char *path); +prom_procfs_buf_t *prom_procfs_buf_new(const char *path); int prom_procfs_buf_destroy(prom_procfs_buf_t *self); -#endif // PROM_PROCFS_I_H - +#endif // PROM_PROCFS_I_H diff --git a/prom/src/prom_procfs_t.h b/prom/src/prom_procfs_t.h index 876af58..7d8b525 100644 --- a/prom/src/prom_procfs_t.h +++ b/prom/src/prom_procfs_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +17,6 @@ #ifndef PROM_PROCFS_T_H #define PROM_PROCFS_T_H - typedef struct prom_procfs_buf { size_t allocated; size_t size; @@ -25,5 +24,4 @@ typedef struct prom_procfs_buf { char *buf; } prom_procfs_buf_t; - -#endif // PROM_PROCFS_T_H \ No newline at end of file +#endif // PROM_PROCFS_T_H diff --git a/prom/src/prom_string_builder.c b/prom/src/prom_string_builder.c index 8d9ca89..22a3c8c 100644 --- a/prom/src/prom_string_builder.c +++ b/prom/src/prom_string_builder.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #include // Public @@ -32,16 +31,16 @@ int prom_string_builder_init(prom_string_builder_t *self); struct prom_string_builder { - char *str; /**< the target string */ - size_t allocated; /**< the size allocated to the string in bytes */ - size_t len; /**< the length of str */ - size_t init_size; /**< the initialize size of space to allocate */ + char *str; /**< the target string */ + size_t allocated; /**< the size allocated to the string in bytes */ + size_t len; /**< the length of str */ + size_t init_size; /**< the initialize size of space to allocate */ }; -prom_string_builder_t* prom_string_builder_new(void) { +prom_string_builder_t *prom_string_builder_new(void) { int r = 0; - prom_string_builder_t *self = (prom_string_builder_t*) prom_malloc(sizeof(prom_string_builder_t)); + prom_string_builder_t *self = (prom_string_builder_t *)prom_malloc(sizeof(prom_string_builder_t)); self->init_size = PROM_STRING_BUILDER_INIT_SIZE; r = prom_string_builder_init(self); if (r) { @@ -55,14 +54,13 @@ prom_string_builder_t* prom_string_builder_new(void) { int prom_string_builder_init(prom_string_builder_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; - self->str = (char*) prom_malloc(self->init_size); + self->str = (char *)prom_malloc(self->init_size); *self->str = '\0'; self->allocated = self->init_size; self->len = 0; return 0; } - int prom_string_builder_destroy(prom_string_builder_t *self) { PROM_ASSERT(self != NULL); if (self == NULL) return 0; @@ -82,9 +80,9 @@ int prom_string_builder_destroy(prom_string_builder_t *self) { static int prom_string_builder_ensure_space(prom_string_builder_t *self, size_t add_len) { PROM_ASSERT(self != NULL); if (self == NULL) return 1; - if (add_len == 0 || self->allocated >= self->len+add_len+1) return 0; - while (self->allocated < self->len+add_len+1) self->allocated <<= 1; - self->str = (char *) prom_realloc(self->str, self->allocated); + if (add_len == 0 || self->allocated >= self->len + add_len + 1) return 0; + while (self->allocated < self->len + add_len + 1) self->allocated <<= 1; + self->str = (char *)prom_realloc(self->str, self->allocated); return 0; } @@ -99,7 +97,7 @@ int prom_string_builder_add_str(prom_string_builder_t *self, const char *str) { r = prom_string_builder_ensure_space(self, len); if (r) return r; - memcpy(self->str+self->len, str, len); + memcpy(self->str + self->len, str, len); self->len += len; self->str[self->len] = '\0'; return 0; @@ -141,15 +139,15 @@ size_t prom_string_builder_len(prom_string_builder_t *self) { return self->len; } -char* prom_string_builder_dump(prom_string_builder_t *self) { +char *prom_string_builder_dump(prom_string_builder_t *self) { PROM_ASSERT(self != NULL); // +1 to accommodate \0 - char* out = (char*) prom_malloc((self->len+1) * sizeof(char)); - memcpy(out, self->str, self->len+1); + char *out = (char *)prom_malloc((self->len + 1) * sizeof(char)); + memcpy(out, self->str, self->len + 1); return out; } -char* prom_string_builder_str(prom_string_builder_t *self) { +char *prom_string_builder_str(prom_string_builder_t *self) { PROM_ASSERT(self != NULL); return self->str; } diff --git a/prom/src/prom_string_builder_i.h b/prom/src/prom_string_builder_i.h index a5cdf5c..999f372 100644 --- a/prom/src/prom_string_builder_i.h +++ b/prom/src/prom_string_builder_i.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,6 @@ * limitations under the License. */ - #ifndef PROM_STRING_BUILDER_I_H #define PROM_STRING_BUILDER_I_H @@ -38,8 +37,7 @@ int prom_string_builder_destroy(prom_string_builder_t *self); * API PRIVATE * @brief Adds a string */ -int prom_string_builder_add_str(prom_string_builder_t *self, const char* str); - +int prom_string_builder_add_str(prom_string_builder_t *self, const char *str); /** * API PRIVATE @@ -47,7 +45,6 @@ int prom_string_builder_add_str(prom_string_builder_t *self, const char* str); */ int prom_string_builder_add_char(prom_string_builder_t *self, char c); - /** * API PRIVATE * @brief Clear the string @@ -70,13 +67,12 @@ size_t prom_string_builder_len(prom_string_builder_t *self); * API PRIVATE * @brief Returns a copy of the string. The returned string must be deallocated when no longer needed. */ -char* prom_string_builder_dump(prom_string_builder_t *self); - +char *prom_string_builder_dump(prom_string_builder_t *self); /** * API PRIVATE * @brief Getter for str member */ -char* prom_string_builder_str(prom_string_builder_t *self); +char *prom_string_builder_str(prom_string_builder_t *self); -#endif // PROM_STRING_BUILDER_I_H +#endif // PROM_STRING_BUILDER_I_H diff --git a/prom/src/prom_string_builder_t.h b/prom/src/prom_string_builder_t.h index 7248733..3cf456a 100644 --- a/prom/src/prom_string_builder_t.h +++ b/prom/src/prom_string_builder_t.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,17 +14,13 @@ * limitations under the License. */ - - #ifndef PROM_STRING_BUILDER_T_H #define PROM_STRING_BUILDER_T_H - struct prom_string_builder; /** * @brief API PRIVATE A structure with functions responsible for building a string */ typedef struct prom_string_builder prom_string_builder_t; - -#endif // PROM_STRING_BUILDER_T_H \ No newline at end of file +#endif // PROM_STRING_BUILDER_T_H diff --git a/prom/test/prom_collector_registry_test.c b/prom/test/prom_collector_registry_test.c index 2229ea7..7aa9990 100644 --- a/prom/test/prom_collector_registry_test.c +++ b/prom/test/prom_collector_registry_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,10 +14,8 @@ * limitations under the License. */ - #include "prom_test_helpers.h" - static void prom_registry_test_init(void); static void prom_registry_test_destroy(void); @@ -35,12 +33,11 @@ void test_large_registry(void) { prom_registry_test_destroy(); } - void test_prom_collector_registry_must_register(void) { prom_registry_test_init(); int r = 0; - const char *labels[] = { "foo" }; + const char *labels[] = {"foo"}; r = prom_counter_inc(test_counter, labels); if (r) TEST_FAIL(); r = prom_gauge_add(test_gauge, 2.0, labels); @@ -60,7 +57,7 @@ void test_prom_collector_registry_bridge(void) { if (test_histogram == NULL) TEST_FAIL_MESSAGE("histogram failed to initialize"); - const char *labels[] = { "foo" }; + const char *labels[] = {"foo"}; prom_counter_inc(test_counter, labels); prom_gauge_set(test_gauge, 2.0, labels); r = prom_histogram_observe(test_histogram, 3.0, NULL); @@ -70,33 +67,38 @@ void test_prom_collector_registry_bridge(void) { const char *result = prom_collector_registry_bridge(PROM_COLLECTOR_REGISTRY_DEFAULT); - const char *expected = "# HELP test_counter counter under test\n# TYPE test_counter counter\ntest_counter{label=\"foo\"} 1.000000\n\n# HELP test_gauge gauge under test\n# TYPE test_gauge gauge\ntest_gauge{label=\"foo\"} 2.000000\n\n# HELP test_histogram histogram under test\n# TYPE test_histogram histogram\ntest_histogram{le=\"5.000000\"} 1.000000\ntest_histogram{le=\"10.000000\"} 2.000000\ntest_histogram{le=\"+Inf\"} 2.000000\ntest_histogram_count 2.000000\ntest_histogram_sum 10.000000\n\n# HELP process_max_fds Maximum number of open file descriptors.\n# TYPE process_max_fds gauge\nprocess_max_fds 1048576.000000\n\n# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.\n# TYPE process_virtual_memory_max_bytes gauge\nprocess_virtual_memory_max_bytes -1.000000\n\n"; + const char *expected = + "# HELP test_counter counter under test\n# TYPE test_counter counter\ntest_counter{label=\"foo\"} 1.000000\n\n# " + "HELP test_gauge gauge under test\n# TYPE test_gauge gauge\ntest_gauge{label=\"foo\"} 2.000000\n\n# HELP " + "test_histogram histogram under test\n# TYPE test_histogram histogram\ntest_histogram{le=\"5.000000\"} " + "1.000000\ntest_histogram{le=\"10.000000\"} 2.000000\ntest_histogram{le=\"+Inf\"} 2.000000\ntest_histogram_count " + "2.000000\ntest_histogram_sum 10.000000\n\n# HELP process_max_fds Maximum number of open file descriptors.\n# " + "TYPE process_max_fds gauge\nprocess_max_fds 1048576.000000\n\n# HELP process_virtual_memory_max_bytes Maximum " + "amount of virtual memory available in bytes.\n# TYPE process_virtual_memory_max_bytes " + "gauge\nprocess_virtual_memory_max_bytes -1.000000\n\n"; TEST_ASSERT_NOT_NULL(strstr(result, expected)); - free((char *) result); + free((char *)result); result = NULL; prom_registry_test_destroy(); } -void test_prom_collector_registry_validate_metric_name(void){ +void test_prom_collector_registry_validate_metric_name(void) { prom_registry_test_init(); - TEST_ASSERT_EQUAL_INT(0, prom_collector_registry_validate_metric_name(PROM_COLLECTOR_REGISTRY_DEFAULT, "this_is_a_name09")); + TEST_ASSERT_EQUAL_INT( + 0, prom_collector_registry_validate_metric_name(PROM_COLLECTOR_REGISTRY_DEFAULT, "this_is_a_name09")); prom_registry_test_destroy(); } void prom_registry_test_init(void) { prom_collector_registry_default_init(); - const char *label[] = { "label" }; - test_counter = prom_collector_registry_must_register_metric(prom_counter_new( - "test_counter", "counter under test", 1, label - )); - test_gauge = prom_collector_registry_must_register_metric(prom_gauge_new( - "test_gauge", "gauge under test", 1, label - )); + const char *label[] = {"label"}; + test_counter = + prom_collector_registry_must_register_metric(prom_counter_new("test_counter", "counter under test", 1, label)); + test_gauge = prom_collector_registry_must_register_metric(prom_gauge_new("test_gauge", "gauge under test", 1, label)); test_histogram = prom_collector_registry_must_register_metric(prom_histogram_new( - "test_histogram", "histogram under test", prom_histogram_buckets_linear(5.0, 5.0, 2), 0, NULL - )); + "test_histogram", "histogram under test", prom_histogram_buckets_linear(5.0, 5.0, 2), 0, NULL)); } static void prom_registry_test_destroy(void) { @@ -113,4 +115,4 @@ int main(int argc, const char **argv) { // RUN_TEST(test_prom_collector_registry_validate_metric_name); // RUN_TEST(test_large_registry); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_collector_test.c b/prom/test/prom_collector_test.c index 95576a9..71aebde 100644 --- a/prom/test/prom_collector_test.c +++ b/prom/test/prom_collector_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,7 +18,7 @@ void test_prom_collector(void) { prom_collector_t *collector = prom_collector_new("test"); - prom_counter_t *counter = prom_counter_new( "test_counter", "counter under test", 0, NULL); + prom_counter_t *counter = prom_counter_new("test_counter", "counter under test", 0, NULL); prom_collector_add_metric(collector, counter); prom_map_t *m = collector->collect_fn(collector); TEST_ASSERT_EQUAL_INT(1, prom_map_size(m)); @@ -27,10 +27,9 @@ void test_prom_collector(void) { } void test_prom_process_collector(void) { - prom_collector_t *collector = prom_collector_process_new( - "/code/prom/test/fixtures/limits", "/code/prom/test/fixtures/stat" - ); - prom_map_t *m = collector->collect_fn(collector); + prom_collector_t *collector = + prom_collector_process_new("/code/prom/test/fixtures/limits", "/code/prom/test/fixtures/stat"); + prom_map_t *m = collector->collect_fn(collector); TEST_ASSERT_EQUAL_INT(6, prom_map_size(m)); prom_collector_destroy(collector); collector = NULL; @@ -41,4 +40,4 @@ int main(int argc, const char **argv) { RUN_TEST(test_prom_collector); RUN_TEST(test_prom_process_collector); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_counter_test.c b/prom/test/prom_counter_test.c index 855a8a1..d58eea4 100644 --- a/prom/test/prom_counter_test.c +++ b/prom/test/prom_counter_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,14 +15,14 @@ */ #include -#include "prom_test_helpers.h" +#include "prom_test_helpers.h" const char *sample_labels_a[] = {"f", "b"}; const char *sample_labels_b[] = {"o", "r"}; void test_counter_inc(void) { - prom_counter_t *c = prom_counter_new("test_counter", "counter under test", 2, (const char *[]) { "foo", "bar" }); + prom_counter_t *c = prom_counter_new("test_counter", "counter under test", 2, (const char *[]){"foo", "bar"}); TEST_ASSERT(c); prom_counter_inc(c, sample_labels_a); @@ -38,11 +38,11 @@ void test_counter_inc(void) { } void test_counter_add(void) { - prom_counter_t *c = prom_counter_new("test_counter", "counter under test", 2, (const char *[]) { "foo", "bar"}); + prom_counter_t *c = prom_counter_new("test_counter", "counter under test", 2, (const char *[]){"foo", "bar"}); TEST_ASSERT(c); prom_counter_add(c, 100000000.1, sample_labels_a); - prom_metric_sample_t *sample = prom_metric_sample_from_labels(c, sample_labels_a); + prom_metric_sample_t *sample = prom_metric_sample_from_labels(c, sample_labels_a); TEST_ASSERT_EQUAL_DOUBLE(100000000.1, sample->r_value); sample = prom_metric_sample_from_labels(c, sample_labels_b); @@ -53,8 +53,8 @@ void test_counter_add(void) { } int main(int argc, const char **argv) { - UNITY_BEGIN(); - RUN_TEST(test_counter_inc); - RUN_TEST(test_counter_add); - return UNITY_END(); -} \ No newline at end of file + UNITY_BEGIN(); + RUN_TEST(test_counter_inc); + RUN_TEST(test_counter_add); + return UNITY_END(); +} diff --git a/prom/test/prom_gauge_test.c b/prom/test/prom_gauge_test.c index 88e7c72..c3ea35b 100644 --- a/prom/test/prom_gauge_test.c +++ b/prom/test/prom_gauge_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,18 +16,16 @@ #include "prom_test_helpers.h" - const char *sample_labels_a[] = {"f", "b"}; const char *sample_labels_b[] = {"o", "r"}; void test_gauge_inc(void) { - prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]) { "foo", "bar" }); + prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]){"foo", "bar"}); TEST_ASSERT(g); prom_gauge_inc(g, sample_labels_a); - - prom_metric_sample_t *sample = prom_metric_sample_from_labels(g, sample_labels_a); + prom_metric_sample_t *sample = prom_metric_sample_from_labels(g, sample_labels_a); TEST_ASSERT_EQUAL_DOUBLE(1.0, sample->r_value); @@ -39,7 +37,7 @@ void test_gauge_inc(void) { } void test_gauge_dec(void) { - prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]) { "foo", "bar" }); + prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]){"foo", "bar"}); TEST_ASSERT(g); prom_gauge_dec(g, sample_labels_a); @@ -47,7 +45,7 @@ void test_gauge_dec(void) { prom_metric_sample_t *sample = prom_metric_sample_from_labels(g, sample_labels_a); TEST_ASSERT_EQUAL_DOUBLE(-1.0, sample->r_value); - sample = prom_metric_sample_from_labels(g, sample_labels_b); + sample = prom_metric_sample_from_labels(g, sample_labels_b); TEST_ASSERT_EQUAL_DOUBLE(0.0, sample->r_value); prom_gauge_destroy(g); @@ -55,7 +53,7 @@ void test_gauge_dec(void) { } void test_gauge_add(void) { - prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]) { "foo", "bar" }); + prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]){"foo", "bar"}); TEST_ASSERT(g); prom_gauge_add(g, 100000000.1, sample_labels_a); @@ -63,7 +61,7 @@ void test_gauge_add(void) { prom_metric_sample_t *sample = prom_metric_sample_from_labels(g, sample_labels_a); TEST_ASSERT_EQUAL_DOUBLE(100000000.1, sample->r_value); - sample = prom_metric_sample_from_labels(g, sample_labels_b); + sample = prom_metric_sample_from_labels(g, sample_labels_b); TEST_ASSERT_EQUAL_DOUBLE(0.0, sample->r_value); prom_gauge_destroy(g); @@ -71,7 +69,7 @@ void test_gauge_add(void) { } void test_gauge_sub(void) { - prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]) { "foo", "bar" }); + prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]){"foo", "bar"}); TEST_ASSERT(g); prom_gauge_sub(g, 100000000.1, sample_labels_a); @@ -86,9 +84,8 @@ void test_gauge_sub(void) { g = NULL; } - void test_gauge_set(void) { - prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]) { "foo", "bar" }); + prom_gauge_t *g = prom_gauge_new("test_gauge", "gauge under test", 2, (const char *[]){"foo", "bar"}); TEST_ASSERT(g); prom_gauge_set(g, 100000000.1, sample_labels_a); @@ -96,21 +93,19 @@ void test_gauge_set(void) { prom_metric_sample_t *sample = prom_metric_sample_from_labels(g, sample_labels_a); TEST_ASSERT_EQUAL_DOUBLE(100000000.1, sample->r_value); - sample = prom_metric_sample_from_labels(g, sample_labels_b); + sample = prom_metric_sample_from_labels(g, sample_labels_b); TEST_ASSERT_EQUAL_DOUBLE(0.0, sample->r_value); prom_gauge_destroy(g); g = NULL; } - - int main(int argc, const char **argv) { - UNITY_BEGIN(); - RUN_TEST(test_gauge_inc); - RUN_TEST(test_gauge_dec); - RUN_TEST(test_gauge_add); - RUN_TEST(test_gauge_sub); - RUN_TEST(test_gauge_set); - return UNITY_END(); -} \ No newline at end of file + UNITY_BEGIN(); + RUN_TEST(test_gauge_inc); + RUN_TEST(test_gauge_dec); + RUN_TEST(test_gauge_add); + RUN_TEST(test_gauge_sub); + RUN_TEST(test_gauge_set); + return UNITY_END(); +} diff --git a/prom/test/prom_histogram_buckets_test.c b/prom/test/prom_histogram_buckets_test.c index 72018ce..fca30fa 100644 --- a/prom/test/prom_histogram_buckets_test.c +++ b/prom/test/prom_histogram_buckets_test.c @@ -1,6 +1,6 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,7 +15,6 @@ * limitations under the License. */ - #include "prom_test_helpers.h" void test_prom_histogram_buckets_new(void) { @@ -23,16 +22,17 @@ void test_prom_histogram_buckets_new(void) { TEST_ASSERT_EQUAL_DOUBLE(1.0, result->upper_bounds[0]); TEST_ASSERT_EQUAL_DOUBLE(2.0, result->upper_bounds[1]); TEST_ASSERT_EQUAL_DOUBLE(3.0, result->upper_bounds[2]); + TEST_ASSERT_EQUAL_INT(3, prom_histogram_buckets_count(result)); prom_histogram_buckets_destroy(result); result = NULL; } - -void test_prom_histogram_buckets_linear(void){ +void test_prom_histogram_buckets_linear(void) { prom_histogram_buckets_t *result = prom_histogram_buckets_linear(0.0, 1.5, 3); TEST_ASSERT_EQUAL_DOUBLE(0.0, result->upper_bounds[0]); TEST_ASSERT_EQUAL_DOUBLE(1.5, result->upper_bounds[1]); TEST_ASSERT_EQUAL_DOUBLE(3.0, result->upper_bounds[2]); + TEST_ASSERT_EQUAL_INT(3, prom_histogram_buckets_count(result)); prom_histogram_buckets_destroy(result); result = NULL; } @@ -42,6 +42,7 @@ void test_prom_histogram_buckets_expontential(void) { TEST_ASSERT_EQUAL_DOUBLE(1.0, result->upper_bounds[0]); TEST_ASSERT_EQUAL_DOUBLE(2.0, result->upper_bounds[1]); TEST_ASSERT_EQUAL_DOUBLE(4.0, result->upper_bounds[2]); + TEST_ASSERT_EQUAL_INT(3, prom_histogram_buckets_count(result)); prom_histogram_buckets_destroy(result); } @@ -51,4 +52,4 @@ int main(int argc, const char **argv) { RUN_TEST(test_prom_histogram_buckets_linear); RUN_TEST(test_prom_histogram_buckets_expontential); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_histogram_test.c b/prom/test/prom_histogram_test.c index 9fe3f33..1eb1aa0 100644 --- a/prom/test/prom_histogram_test.c +++ b/prom/test/prom_histogram_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,14 +14,11 @@ * limitations under the License. */ - #include "prom_test_helpers.h" - -void test_prom_histogram(void){ - prom_histogram_t *h = prom_histogram_new( - "test_histogram", "histogram under test", prom_histogram_buckets_linear(5.0, 5.0, 3), 0, NULL - ); +void test_prom_histogram(void) { + prom_histogram_t *h = + prom_histogram_new("test_histogram", "histogram under test", prom_histogram_buckets_linear(5.0, 5.0, 3), 0, NULL); prom_histogram_observe(h, 1.0, NULL); prom_histogram_observe(h, 7.0, NULL); @@ -33,42 +30,42 @@ void test_prom_histogram(void){ // Test counter for each bucket char *bucket_key = prom_metric_sample_histogram_bucket_to_str(5.0); const char *l_value = prom_map_get(h_sample->l_values, bucket_key); - prom_metric_sample_t *sample = (prom_metric_sample_t*) prom_map_get(h_sample->samples, l_value); + prom_metric_sample_t *sample = (prom_metric_sample_t *)prom_map_get(h_sample->samples, l_value); TEST_ASSERT_EQUAL_STRING("test_histogram{le=\"5.000000\"}", sample->l_value); TEST_ASSERT_EQUAL_DOUBLE(1.0, sample->r_value); - free((char *) bucket_key); + free((char *)bucket_key); bucket_key = NULL; bucket_key = prom_metric_sample_histogram_bucket_to_str(10.0); l_value = prom_map_get(h_sample->l_values, bucket_key); - sample = (prom_metric_sample_t*) prom_map_get(h_sample->samples, l_value); + sample = (prom_metric_sample_t *)prom_map_get(h_sample->samples, l_value); TEST_ASSERT_EQUAL_STRING("test_histogram{le=\"10.000000\"}", sample->l_value); TEST_ASSERT_EQUAL_DOUBLE(2.0, sample->r_value); - free((char *) bucket_key); + free((char *)bucket_key); bucket_key = NULL; bucket_key = prom_metric_sample_histogram_bucket_to_str(15.0); l_value = prom_map_get(h_sample->l_values, bucket_key); - sample = (prom_metric_sample_t*) prom_map_get(h_sample->samples, l_value); + sample = (prom_metric_sample_t *)prom_map_get(h_sample->samples, l_value); TEST_ASSERT_EQUAL_STRING("test_histogram{le=\"15.000000\"}", sample->l_value); TEST_ASSERT_EQUAL_DOUBLE(3.0, sample->r_value); - free((char *) bucket_key); + free((char *)bucket_key); bucket_key = NULL; l_value = prom_map_get(h_sample->l_values, "+Inf"); - sample = (prom_metric_sample_t*) prom_map_get(h_sample->samples, l_value); + sample = (prom_metric_sample_t *)prom_map_get(h_sample->samples, l_value); TEST_ASSERT_EQUAL_STRING("test_histogram{le=\"+Inf\"}", sample->l_value); TEST_ASSERT_EQUAL_DOUBLE(4.0, sample->r_value); // Test total count. Should equal value ini +Inf l_value = prom_map_get(h_sample->l_values, "count"); - prom_metric_sample_t *sample_count = (prom_metric_sample_t*) prom_map_get(h_sample->samples, l_value); + prom_metric_sample_t *sample_count = (prom_metric_sample_t *)prom_map_get(h_sample->samples, l_value); TEST_ASSERT_EQUAL_STRING("test_histogram_count", sample_count->l_value); TEST_ASSERT_EQUAL_DOUBLE(4.0, sample_count->r_value); // Test sum l_value = prom_map_get(h_sample->l_values, "sum"); - sample = (prom_metric_sample_t*) prom_map_get(h_sample->samples, l_value); + sample = (prom_metric_sample_t *)prom_map_get(h_sample->samples, l_value); TEST_ASSERT_EQUAL_STRING("test_histogram_sum", sample->l_value); TEST_ASSERT_EQUAL_DOUBLE(41.0, sample->r_value); @@ -76,9 +73,8 @@ void test_prom_histogram(void){ h = NULL; } - int main(int argc, const char **argv) { UNITY_BEGIN(); RUN_TEST(test_prom_histogram); - return UNITY_END(); -} \ No newline at end of file + return UNITY_END(); +} diff --git a/prom/test/prom_linked_list_test.c b/prom/test/prom_linked_list_test.c index 4e610b0..c3f8af2 100644 --- a/prom/test/prom_linked_list_test.c +++ b/prom/test/prom_linked_list_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,10 +14,8 @@ * limitations under the License. */ - #include "prom_test_helpers.h" - void test_prom_linked_list_append(void) { prom_linked_list_t *l = prom_linked_list_new(); TEST_ASSERT(l); @@ -31,8 +29,8 @@ void test_prom_linked_list_append(void) { prom_linked_list_append(l, two); prom_linked_list_append(l, three); - prom_linked_list_node_t* current_node = l->head; - char *current_str = (char *) current_node->item; + prom_linked_list_node_t *current_node = l->head; + char *current_str = (char *)current_node->item; TEST_ASSERT_EQUAL_STRING("one", current_str); current_node = current_node->next; current_str = current_node->item; @@ -58,8 +56,8 @@ void test_prom_linked_list_push(void) { prom_linked_list_push(l, two); prom_linked_list_push(l, three); - prom_linked_list_node_t* current_node = l->head; - char *current_str = (char *) current_node->item; + prom_linked_list_node_t *current_node = l->head; + char *current_str = (char *)current_node->item; TEST_ASSERT_EQUAL_STRING("three", current_str); current_node = current_node->next; current_str = current_node->item; @@ -74,8 +72,8 @@ void test_prom_linked_list_push(void) { void test_prom_linked_list_remove(void) { auto prom_linked_list_compare_t compare_fn(void *item_a, void *item_b) { - const char *str_a = (const char *) item_a; - const char *str_b = (const char *) item_b; + const char *str_a = (const char *)item_a; + const char *str_b = (const char *)item_b; return strcmp(str_a, str_b); } @@ -97,11 +95,10 @@ void test_prom_linked_list_remove(void) { list = NULL; } - int main(int argc, const char **argv) { UNITY_BEGIN(); RUN_TEST(test_prom_linked_list_append); RUN_TEST(test_prom_linked_list_push); RUN_TEST(test_prom_linked_list_remove); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_map_test.c b/prom/test/prom_map_test.c index 2241988..71649ea 100644 --- a/prom/test/prom_map_test.c +++ b/prom/test/prom_map_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,25 +14,20 @@ * limitations under the License. */ - #include "prom_test_helpers.h" - void test_prom_map(void) { prom_map_t *map = prom_map_new(); prom_map_set(map, "foo", "bar"); prom_map_set(map, "bing", "bang"); - TEST_ASSERT_EQUAL_STRING("bar", (const char*) prom_map_get(map, "foo")); - TEST_ASSERT_EQUAL_STRING("bang", (const char*) prom_map_get(map, "bing")); + TEST_ASSERT_EQUAL_STRING("bar", (const char *)prom_map_get(map, "foo")); + TEST_ASSERT_EQUAL_STRING("bang", (const char *)prom_map_get(map, "bing")); TEST_ASSERT_NULL(prom_map_get(map, "nope")); TEST_ASSERT_EQUAL_INT(2, prom_map_size(map)); - for ( - prom_linked_list_node_t *current_node = map->keys->head; - current_node != NULL; - current_node = current_node->next - ) { - const char *key = (const char *) current_node->item; + for (prom_linked_list_node_t *current_node = map->keys->head; current_node != NULL; + current_node = current_node->next) { + const char *key = (const char *)current_node->item; const char *expected; if (strcmp(key, "foo") == 0) { @@ -51,7 +46,6 @@ void test_prom_map(void) { } void test_prom_map_when_large(void) { - prom_map_t *map = prom_map_new(); prom_map_set_free_value_fn(map, free); @@ -59,25 +53,25 @@ void test_prom_map_when_large(void) { for (int i = 1; i <= 10000; i++) { char buf[4]; sprintf(buf, "%d", i); - const char *k = (const char *) buf; + const char *k = (const char *)buf; int *set = malloc(sizeof(int)); *set = i; - prom_map_set(map, k, (void *) set); - TEST_ASSERT_EQUAL_INT(i, *((int*) prom_map_get(map, k))); + prom_map_set(map, k, (void *)set); + TEST_ASSERT_EQUAL_INT(i, *((int *)prom_map_get(map, k))); } // Update one of the keys int *at_50 = malloc(sizeof(int)); *at_50 = 5000; - prom_map_set(map, "50", (void *) at_50); - TEST_ASSERT_EQUAL_INT(5000, *((int*) prom_map_get(map, "50"))); + prom_map_set(map, "50", (void *)at_50); + TEST_ASSERT_EQUAL_INT(5000, *((int *)prom_map_get(map, "50"))); // Ensure each key and value is correct for (int i = 1; i <= 10000; i++) { char buf[5]; sprintf(buf, "%d", i); - const char *k = (const char *) buf; - int actual = *((int*) prom_map_get(map, k)); + const char *k = (const char *)buf; + int actual = *((int *)prom_map_get(map, k)); if (i == 50) { TEST_ASSERT_EQUAL_INT(5000, actual); } else { diff --git a/prom/test/prom_metric_formatter_test.c b/prom/test/prom_metric_formatter_test.c index c774620..ccc40da 100644 --- a/prom/test/prom_metric_formatter_test.c +++ b/prom/test/prom_metric_formatter_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,14 +14,12 @@ * limitations under the License. */ - #include "prom_test_helpers.h" - void test_prom_metric_formatter_load_l_value(void) { prom_metric_formatter_t *mf = prom_metric_formatter_new(); - const char *keys[] = { "foo", "bar", "bing" }; - const char *values[] = { "one", "two", "three" }; + const char *keys[] = {"foo", "bar", "bing"}; + const char *values[] = {"one", "two", "three"}; prom_metric_formatter_load_l_value(mf, "test", NULL, 3, keys, values); char *actual = prom_metric_formatter_dump(mf); char *expected = "test{foo=\"one\",bar=\"two\",bing=\"three\"}"; @@ -49,11 +47,11 @@ void test_prom_metric_formatter_load_sample(void) { mf = NULL; } -void test_prom_metric_formatter_load_metric(void){ +void test_prom_metric_formatter_load_metric(void) { prom_metric_formatter_t *mf = prom_metric_formatter_new(); - const char *counter_keys[] = { "foo", "bar" }; - const char *sample_a[] = { "f", "b" }; - const char *sample_b[] = { "o", "r" }; + const char *counter_keys[] = {"foo", "bar"}; + const char *sample_a[] = {"f", "b"}; + const char *sample_b[] = {"o", "r"}; prom_metric_t *m = prom_metric_new(PROM_COUNTER, "test_counter", "counter under test", 2, counter_keys); prom_metric_sample_t *s_a = prom_metric_sample_from_labels(m, sample_a); prom_metric_sample_add(s_a, 2.3); @@ -62,9 +60,12 @@ void test_prom_metric_formatter_load_metric(void){ prom_metric_formatter_load_metric(mf, m); const char *result = prom_metric_formatter_dump(mf); - TEST_ASSERT_EQUAL_STRING("# HELP test_counter counter under test\n# TYPE test_counter counter\ntest_counter{foo=\"f\",bar=\"b\"} 2.300000\ntest_counter{foo=\"o\",bar=\"r\"} 4.600000\n\n", result); + TEST_ASSERT_EQUAL_STRING( + "# HELP test_counter counter under test\n# TYPE test_counter counter\ntest_counter{foo=\"f\",bar=\"b\"} " + "2.300000\ntest_counter{foo=\"o\",bar=\"r\"} 4.600000\n\n", + result); - free((char *) result); + free((char *)result); result = NULL; prom_metric_destroy(m); m = NULL; @@ -90,9 +91,14 @@ void test_prom_metric_formatter_load_metrics(void) { prom_metric_formatter_load_metrics(mf, PROM_COLLECTOR_REGISTRY_DEFAULT->collectors); const char *result = prom_metric_formatter_dump(mf); - const char *expected = "# HELP test_counter_a counter under test\n# TYPE test_counter_a counter\ntest_counter_a 2.300000\n\n# HELP test_counter_b counter under test\n# TYPE test_counter_b counter\ntest_counter_b 4.600000\n\n# HELP process_max_fds Maximum number of open file descriptors.\n# TYPE process_max_fds gauge\nprocess_max_fds 1048576.000000\n\n# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.\n# TYPE process_virtual_memory_max_bytes gauge\nprocess_virtual_memory_max_bytes -1.000000\n\n"; + const char *expected = + "# HELP test_counter_a counter under test\n# TYPE test_counter_a counter\ntest_counter_a 2.300000\n\n# HELP " + "test_counter_b counter under test\n# TYPE test_counter_b counter\ntest_counter_b 4.600000\n\n# HELP " + "process_max_fds Maximum number of open file descriptors.\n# TYPE process_max_fds gauge\nprocess_max_fds " + "1048576.000000\n\n# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in " + "bytes.\n# TYPE process_virtual_memory_max_bytes gauge\nprocess_virtual_memory_max_bytes -1.000000\n\n"; TEST_ASSERT_NOT_NULL(strstr(result, expected)); - free((char *) result); + free((char *)result); result = NULL; r = prom_metric_formatter_destroy(mf); @@ -114,4 +120,4 @@ int main(int argc, const char **argv) { RUN_TEST(test_prom_metric_formatter_load_metric); RUN_TEST(test_prom_metric_formatter_load_metrics); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_metric_sample_test.c b/prom/test/prom_metric_sample_test.c index d2a42bb..d7dd013 100644 --- a/prom/test/prom_metric_sample_test.c +++ b/prom/test/prom_metric_sample_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,12 +14,9 @@ * limitations under the License. */ - - #include "prom_test_helpers.h" - -const char* l_value = "test{foo=\"bar\"}"; +const char *l_value = "test{foo=\"bar\"}"; void test_prom_metric_sample_add(void) { prom_metric_sample_t *s = prom_metric_sample_new(PROM_COUNTER, l_value, 0.0); @@ -72,4 +69,4 @@ int main(int argc, const char **argv) { RUN_TEST(test_prom_metric_sample_sub); RUN_TEST(test_prom_metric_set); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_metric_test.c b/prom/test/prom_metric_test.c index 959060f..be4ce0c 100644 --- a/prom/test/prom_metric_test.c +++ b/prom/test/prom_metric_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,35 +14,32 @@ * limitations under the License. */ - #include "prom_test_helpers.h" void test_metric_with_no_labels(void) { prom_metric_t *metric = prom_metric_new(PROM_GAUGE, "test_counter", "counter under test", 0, NULL); - prom_metric_sample_t* sample = prom_metric_sample_from_labels(metric, NULL); + prom_metric_sample_t *sample = prom_metric_sample_from_labels(metric, NULL); prom_metric_sample_set(sample, 1.0); sample = prom_metric_sample_from_labels(metric, NULL); - TEST_ASSERT_EQUAL_DOUBLE(1.0, (_Atomic double) sample->r_value); + TEST_ASSERT_EQUAL_DOUBLE(1.0, (_Atomic double)sample->r_value); prom_metric_destroy(metric); metric = NULL; } - void test_metric_sample_from_labels(void) { - prom_metric_t *metric = prom_metric_new(PROM_GAUGE, "test_metric", "test counter", 2, (const char *[]) {"foo", "bar"}); - const char *values[] = { "bing", "bang" }; - prom_metric_sample_t* sample = prom_metric_sample_from_labels(metric, values); + prom_metric_t *metric = prom_metric_new(PROM_GAUGE, "test_metric", "test counter", 2, (const char *[]){"foo", "bar"}); + const char *values[] = {"bing", "bang"}; + prom_metric_sample_t *sample = prom_metric_sample_from_labels(metric, values); prom_metric_sample_set(sample, 1.0); sample = prom_metric_sample_from_labels(metric, values); - TEST_ASSERT_EQUAL_DOUBLE(1.0, (_Atomic double) sample->r_value); + TEST_ASSERT_EQUAL_DOUBLE(1.0, (_Atomic double)sample->r_value); prom_metric_destroy(metric); metric = NULL; } - int main(int argc, const char **argv) { UNITY_BEGIN(); RUN_TEST(test_metric_with_no_labels); RUN_TEST(test_metric_sample_from_labels); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_process_limits_test.c b/prom/test/prom_process_limits_test.c index 05dc511..a2fd4b5 100644 --- a/prom/test/prom_process_limits_test.c +++ b/prom/test/prom_process_limits_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,14 +15,13 @@ */ #include -#include #include - -#include "unity.h" +#include #include "prom_map_i.h" #include "prom_process_limits_i.h" #include "prom_process_limits_t.h" +#include "unity.h" const char *path = "/code/prom/test/fixtures/limits"; @@ -36,38 +35,38 @@ void test_prom_process_limits_file_parsing(void) { TEST_ASSERT_EQUAL_INT(16, prom_map_size(m)); - prom_process_limits_row_t *row = (prom_process_limits_row_t*) prom_map_get(m, "Max cpu time"); + prom_process_limits_row_t *row = (prom_process_limits_row_t *)prom_map_get(m, "Max cpu time"); if (!row) TEST_FAIL(); TEST_ASSERT_EQUAL_INT(-1, row->soft); TEST_ASSERT_EQUAL_INT(-1, row->hard); TEST_ASSERT_EQUAL_STRING("Max cpu time", row->limit); TEST_ASSERT_EQUAL_STRING("seconds", row->units); - row = (prom_process_limits_row_t*) prom_map_get(m, "Max file size"); + row = (prom_process_limits_row_t *)prom_map_get(m, "Max file size"); TEST_ASSERT_EQUAL_INT(-1, row->soft); TEST_ASSERT_EQUAL_INT(-1, row->hard); TEST_ASSERT_EQUAL_STRING("Max file size", row->limit); TEST_ASSERT_EQUAL_STRING("bytes", row->units); - row = (prom_process_limits_row_t*) prom_map_get(m, "Max data size"); + row = (prom_process_limits_row_t *)prom_map_get(m, "Max data size"); TEST_ASSERT_EQUAL_INT(-1, row->soft); TEST_ASSERT_EQUAL_INT(-1, row->hard); TEST_ASSERT_EQUAL_STRING("Max data size", row->limit); TEST_ASSERT_EQUAL_STRING("bytes", row->units); - row = (prom_process_limits_row_t*) prom_map_get(m, "Max stack size"); + row = (prom_process_limits_row_t *)prom_map_get(m, "Max stack size"); TEST_ASSERT_EQUAL_INT(8388608, row->soft); TEST_ASSERT_EQUAL_INT(-1, row->hard); TEST_ASSERT_EQUAL_STRING("Max stack size", row->limit); TEST_ASSERT_EQUAL_STRING("bytes", row->units); - row = (prom_process_limits_row_t*) prom_map_get(m, "Max processes"); + row = (prom_process_limits_row_t *)prom_map_get(m, "Max processes"); TEST_ASSERT_EQUAL_INT(-1, row->soft); TEST_ASSERT_EQUAL_INT(-1, row->hard); TEST_ASSERT_EQUAL_STRING("Max processes", row->limit); TEST_ASSERT_EQUAL_STRING("processes", row->units); - row = (prom_process_limits_row_t*) prom_map_get(m, "Max pending signals"); + row = (prom_process_limits_row_t *)prom_map_get(m, "Max pending signals"); TEST_ASSERT_EQUAL_INT(23701, row->soft); TEST_ASSERT_EQUAL_INT(23701, row->hard); TEST_ASSERT_EQUAL_STRING("Max pending signals", row->limit); @@ -80,29 +79,28 @@ void test_prom_process_limits_file_parsing(void) { } void test_prom_process_limits_rdp_next_token(void) { - prom_process_limits_file_t f = { .size = 4, .index = 0, .buf = " \t!" }; + prom_process_limits_file_t f = {.size = 4, .index = 0, .buf = " \t!"}; prom_process_limits_file_t *fp = &f; prom_process_limits_rdp_next_token(fp); - TEST_ASSERT_EQUAL_INT(2, fp->index); TEST_ASSERT_EQUAL_INT('!', fp->buf[fp->index]); } void test_prom_process_limits_rdp_match(void) { - prom_process_limits_file_t f = { .size = 4, .index = 0, .buf = "foo" }; + prom_process_limits_file_t f = {.size = 4, .index = 0, .buf = "foo"}; prom_process_limits_file_t *fp = &f; TEST_ASSERT_TRUE(prom_process_limits_rdp_match(fp, "foo")); } -void test_prom_process_limits_rdp_hard_limit(void){ +void test_prom_process_limits_rdp_hard_limit(void) { // Test unlimited value - prom_process_limits_file_t f = { .size = 13, .index = 0, .buf = "unlimited " }; + prom_process_limits_file_t f = {.size = 13, .index = 0, .buf = "unlimited "}; prom_process_limits_file_t *fp = &f; prom_process_limits_current_row_t *cr = prom_process_limits_current_row_new(); - prom_map_t* m = prom_map_new(); + prom_map_t *m = prom_map_new(); TEST_ASSERT_TRUE(prom_process_limits_rdp_hard_limit(fp, m, cr)); TEST_ASSERT_EQUAL_INT(-1, cr->hard); @@ -123,13 +121,13 @@ void test_prom_process_limits_rdp_hard_limit(void){ cr = NULL; } -void test_prom_process_limits_rdp_word(void){ - // Test unlimited value - prom_process_limits_file_t f = { .size = 13, .index = 0, .buf = "unlimited " }; +void test_prom_process_limits_rdp_word(void) { + // Test unlimited value + prom_process_limits_file_t f = {.size = 13, .index = 0, .buf = "unlimited "}; prom_process_limits_file_t *fp = &f; prom_process_limits_current_row_t *cr = prom_process_limits_current_row_new(); - prom_map_t* m = prom_map_new(); + prom_map_t *m = prom_map_new(); TEST_ASSERT_TRUE(prom_process_limits_rdp_word(fp, m, cr)); TEST_ASSERT_EQUAL_INT(9, fp->index); @@ -140,12 +138,12 @@ void test_prom_process_limits_rdp_word(void){ cr = NULL; } -void test_prom_process_limits_rdp_word_and_space(void){ - prom_process_limits_file_t f = { .size = 8, .index = 0, .buf = "foo bar" }; +void test_prom_process_limits_rdp_word_and_space(void) { + prom_process_limits_file_t f = {.size = 8, .index = 0, .buf = "foo bar"}; prom_process_limits_file_t *fp = &f; prom_process_limits_current_row_t *cr = prom_process_limits_current_row_new(); - prom_map_t* m = prom_map_new(); + prom_map_t *m = prom_map_new(); TEST_ASSERT_TRUE(prom_process_limits_rdp_word_and_space(fp, m, cr)); TEST_ASSERT_EQUAL_INT(4, fp->index); @@ -158,11 +156,11 @@ void test_prom_process_limits_rdp_word_and_space(void){ } void test_prom_process_limits_rdp_limit(void) { - prom_process_limits_file_t f = { .size = 16, .index = 0, .buf = "Max cpu time " }; + prom_process_limits_file_t f = {.size = 16, .index = 0, .buf = "Max cpu time "}; prom_process_limits_file_t *fp = &f; prom_process_limits_current_row_t *cr = prom_process_limits_current_row_new(); - prom_map_t* m = prom_map_new(); + prom_map_t *m = prom_map_new(); TEST_ASSERT_TRUE(prom_process_limits_rdp_limit(fp, m, cr)); TEST_ASSERT_EQUAL_INT(12, fp->index); @@ -176,11 +174,11 @@ void test_prom_process_limits_rdp_limit(void) { } void test_prom_process_limits_rdp_letter(void) { - prom_process_limits_file_t f = { .size = 4, .index = 0, .buf = "foo" }; + prom_process_limits_file_t f = {.size = 4, .index = 0, .buf = "foo"}; prom_process_limits_file_t *fp = &f; prom_process_limits_current_row_t *cr = prom_process_limits_current_row_new(); - prom_map_t* m = prom_map_new(); + prom_map_t *m = prom_map_new(); TEST_ASSERT_TRUE(prom_process_limits_rdp_letter(fp, m, cr)); @@ -214,4 +212,4 @@ int main(int argc, const char **argv) { RUN_TEST(test_prom_process_limits_file_parsing); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_procfs_test.c b/prom/test/prom_procfs_test.c index 8a4bf07..656684e 100644 --- a/prom/test/prom_procfs_test.c +++ b/prom/test/prom_procfs_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,4 +28,4 @@ int main(int argc, const char **argv) { UNITY_BEGIN(); RUN_TEST(test_prom_procfs_buf); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_string_builder_test.c b/prom/test/prom_string_builder_test.c index 552efff..45a8de2 100644 --- a/prom/test/prom_string_builder_test.c +++ b/prom/test/prom_string_builder_test.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,14 +14,14 @@ * limitations under the License. */ - #include "prom_test_helpers.h" void test_prom_string_builder_add_str(void) { prom_string_builder_t *sb = prom_string_builder_new(); prom_string_builder_add_str(sb, "fooooooooooooooooooooooooooooooooo"); prom_string_builder_add_str(sb, " baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaar"); - TEST_ASSERT_EQUAL_STRING(prom_string_builder_str(sb), "fooooooooooooooooooooooooooooooooo baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaar"); + TEST_ASSERT_EQUAL_STRING(prom_string_builder_str(sb), + "fooooooooooooooooooooooooooooooooo baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaar"); prom_string_builder_destroy(sb); sb = NULL; @@ -49,7 +49,7 @@ void test_prom_string_builder_dump(void) { TEST_ASSERT_EQUAL_STRING(original, result); prom_string_builder_destroy(sb); - free((char *) result); + free((char *)result); result = NULL; sb = NULL; } @@ -60,4 +60,4 @@ int main(int argc, const char **argv) { RUN_TEST(test_prom_string_builder_add_char); RUN_TEST(test_prom_string_builder_dump); return UNITY_END(); -} \ No newline at end of file +} diff --git a/prom/test/prom_test_helpers.c b/prom/test/prom_test_helpers.c index 45385cc..9f40f3e 100644 --- a/prom/test/prom_test_helpers.c +++ b/prom/test/prom_test_helpers.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,4 +15,3 @@ */ #include "prom_test_helpers.h" - diff --git a/prom/test/prom_test_helpers.h b/prom/test/prom_test_helpers.h index 053fa0a..4948c4c 100644 --- a/prom/test/prom_test_helpers.h +++ b/prom/test/prom_test_helpers.h @@ -3,31 +3,29 @@ #include #include -#include "unity.h" - #include "prom.h" +#include "prom_collector_registry_t.h" +#include "prom_collector_t.h" +#include "prom_linked_list_i.h" +#include "prom_linked_list_t.h" #include "prom_map_i.h" -#include "prom_metric_t.h" -#include "prom_string_builder_i.h" -#include "prom_process_fds_t.h" +#include "prom_map_t.h" +#include "prom_metric_formatter_i.h" +#include "prom_metric_formatter_t.h" +#include "prom_metric_i.h" +#include "prom_metric_sample_histogram_i.h" #include "prom_metric_sample_histogram_t.h" +#include "prom_metric_sample_i.h" #include "prom_metric_sample_t.h" -#include "prom_linked_list_t.h" -#include "prom_metric_formatter_i.h" +#include "prom_metric_t.h" +#include "prom_process_fds_i.h" +#include "prom_process_fds_t.h" +#include "prom_process_limits_i.h" #include "prom_process_limits_t.h" #include "prom_process_stat_i.h" #include "prom_process_stat_t.h" -#include "prom_metric_formatter_t.h" -#include "prom_process_limits_i.h" -#include "prom_linked_list_i.h" -#include "prom_metric_sample_i.h" -#include "prom_metric_sample_histogram_i.h" -#include "prom_collector_registry_t.h" -#include "prom_collector_t.h" -#include "prom_string_builder_t.h" -#include "prom_metric_i.h" -#include "prom_map_t.h" #include "prom_procfs_i.h" #include "prom_procfs_t.h" -#include "prom_process_fds_i.h" -#include "prom_process_fds_t.h" \ No newline at end of file +#include "prom_string_builder_i.h" +#include "prom_string_builder_t.h" +#include "unity.h" diff --git a/promhttp/include/promhttp.h b/promhttp/include/promhttp.h index 5f6bc07..fc47523 100644 --- a/promhttp/include/promhttp.h +++ b/promhttp/include/promhttp.h @@ -1,5 +1,5 @@ /* - Copyright 2019 DigitalOcean Inc. + Copyright 2019-2020 DigitalOcean Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -19,13 +19,13 @@ * @brief Provides a HTTP endpoint for metric exposition * References: * * MHD_FLAG: https://www.gnu.org/software/libmicrohttpd/manual/libmicrohttpd.html#microhttpd_002dconst - * * MHD_AcceptPolicyCallback: https://www.gnu.org/software/libmicrohttpd/manual/libmicrohttpd.html#index-_002aMHD_005fAcceptPolicyCallback + * * MHD_AcceptPolicyCallback: + * https://www.gnu.org/software/libmicrohttpd/manual/libmicrohttpd.html#index-_002aMHD_005fAcceptPolicyCallback */ #include #include "microhttpd.h" - #include "prom_collector_registry.h" /** @@ -44,7 +44,5 @@ void promhttp_set_active_collector_registry(prom_collector_registry_t *active_re * * @return struct MHD_Daemon* */ -struct MHD_Daemon* promhttp_start_daemon(unsigned int flags, - unsigned short port, - MHD_AcceptPolicyCallback apc, - void *apc_cls); \ No newline at end of file +struct MHD_Daemon *promhttp_start_daemon(unsigned int flags, unsigned short port, MHD_AcceptPolicyCallback apc, + void *apc_cls); diff --git a/promhttp/src/promhttp.c b/promhttp/src/promhttp.c index be38f1d..d94a53e 100644 --- a/promhttp/src/promhttp.c +++ b/promhttp/src/promhttp.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,11 +14,9 @@ * limitations under the License. */ - #include #include "microhttpd.h" - #include "prom.h" prom_collector_registry_t *PROM_ACTIVE_REGISTRY; @@ -31,49 +29,37 @@ void promhttp_set_active_collector_registry(prom_collector_registry_t *active_re } } -int promhttp_handler(void *cls, - struct MHD_Connection *connection, - const char *url, - const char *method, - const char *version, - const char *upload_data, - size_t *upload_data_size, - void **con_cls) -{ +int promhttp_handler(void *cls, struct MHD_Connection *connection, const char *url, const char *method, + const char *version, const char *upload_data, size_t *upload_data_size, void **con_cls) { if (strcmp(method, "GET") != 0) { char *buf = "Invalid HTTP Method\n"; - struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void*) buf, MHD_RESPMEM_PERSISTENT); + struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void *)buf, MHD_RESPMEM_PERSISTENT); int ret = MHD_queue_response(connection, MHD_HTTP_BAD_REQUEST, response); MHD_destroy_response(response); return ret; } if (strcmp(url, "/") == 0) { char *buf = "OK\n"; - struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void*) buf, MHD_RESPMEM_PERSISTENT); + struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void *)buf, MHD_RESPMEM_PERSISTENT); int ret = MHD_queue_response(connection, MHD_HTTP_OK, response); MHD_destroy_response(response); return ret; } if (strcmp(url, "/metrics") == 0) { const char *buf = prom_collector_registry_bridge(PROM_ACTIVE_REGISTRY); - struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void*) buf, MHD_RESPMEM_MUST_FREE); + struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void *)buf, MHD_RESPMEM_MUST_FREE); int ret = MHD_queue_response(connection, MHD_HTTP_OK, response); MHD_destroy_response(response); return ret; } - char *buf = "Bad Request\n"; - struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void*) buf, MHD_RESPMEM_PERSISTENT); - int ret = MHD_queue_response(connection, MHD_HTTP_BAD_REQUEST, response); - MHD_destroy_response(response); - return ret; + char *buf = "Bad Request\n"; + struct MHD_Response *response = MHD_create_response_from_buffer(strlen(buf), (void *)buf, MHD_RESPMEM_PERSISTENT); + int ret = MHD_queue_response(connection, MHD_HTTP_BAD_REQUEST, response); + MHD_destroy_response(response); + return ret; } - -struct MHD_Daemon* promhttp_start_daemon(unsigned int flags, - unsigned short port, - MHD_AcceptPolicyCallback apc, - void *apc_cls) -{ +struct MHD_Daemon *promhttp_start_daemon(unsigned int flags, unsigned short port, MHD_AcceptPolicyCallback apc, + void *apc_cls) { return MHD_start_daemon(flags, port, apc, apc_cls, &promhttp_handler, NULL, MHD_OPTION_END); } - diff --git a/promtest/test/promtest.c b/promtest/test/promtest.c index 446de16..4c7721b 100644 --- a/promtest/test/promtest.c +++ b/promtest/test/promtest.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,16 +14,14 @@ * limitations under the License. */ -#include "unity.h" - -#include "promtest_helpers.h" #include "promtest_counter.h" #include "promtest_gauge.h" - +#include "promtest_helpers.h" +#include "unity.h" int main(int argc, const char **argv) { UNITY_BEGIN(); RUN_TEST(promtest_counter); RUN_TEST(promtest_gauge); return UNITY_END(); -} \ No newline at end of file +} diff --git a/promtest/test/promtest_counter.c b/promtest/test/promtest_counter.c index 923c8a2..224a590 100644 --- a/promtest/test/promtest_counter.c +++ b/promtest/test/promtest_counter.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -44,8 +44,7 @@ void promtest_counter(void) { // Start each thread for (int i = 0; i < PROMTEST_THREAD_POOL_SIZE; i++) { - if (pthread_create(&(thread_pool[i]), NULL, promtest_counter_handler, - NULL)) { + if (pthread_create(&(thread_pool[i]), NULL, promtest_counter_handler, NULL)) { TEST_FAIL_MESSAGE("failed to create thread"); } } @@ -99,15 +98,14 @@ int promtest_counter_setup(void) { prom_collector_registry_default_init(); // Set the counter - foo_counter = prom_collector_registry_must_register_metric( - prom_counter_new("foo_counter", "counter for foo", 0, NULL)); + foo_counter = + prom_collector_registry_must_register_metric(prom_counter_new("foo_counter", "counter for foo", 0, NULL)); // Set the collector registry on the handler to the default registry promhttp_set_active_collector_registry(NULL); // Start the HTTP server - promtest_daemon = - promhttp_start_daemon(MHD_USE_SELECT_INTERNALLY, 8000, NULL, NULL); + promtest_daemon = promhttp_start_daemon(MHD_USE_SELECT_INTERNALLY, 8000, NULL, NULL); if (promtest_daemon == NULL) return 1; diff --git a/promtest/test/promtest_counter.h b/promtest/test/promtest_counter.h index a94817a..b93facb 100644 --- a/promtest/test/promtest_counter.h +++ b/promtest/test/promtest_counter.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,4 +26,4 @@ int promtest_counter_teardown(void); void promtest_counter(void); -#endif // PROMTEST_COUNTER_H \ No newline at end of file +#endif // PROMTEST_COUNTER_H diff --git a/promtest/test/promtest_gauge.c b/promtest/test/promtest_gauge.c index fd6244d..36ce3cc 100644 --- a/promtest/test/promtest_gauge.c +++ b/promtest/test/promtest_gauge.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -98,15 +98,13 @@ int promtest_gauge_setup(void) { prom_collector_registry_default_init(); // Set the gauge - foo_gauge = prom_collector_registry_must_register_metric( - prom_gauge_new("foo_gauge", "gauge for foo", 0, NULL)); + foo_gauge = prom_collector_registry_must_register_metric(prom_gauge_new("foo_gauge", "gauge for foo", 0, NULL)); // Set the collector registry on the handler to the default registry promhttp_set_active_collector_registry(NULL); // Start the HTTP server - promtest_daemon = - promhttp_start_daemon(MHD_USE_SELECT_INTERNALLY, 8000, NULL, NULL); + promtest_daemon = promhttp_start_daemon(MHD_USE_SELECT_INTERNALLY, 8000, NULL, NULL); if (promtest_daemon == NULL) return 1; diff --git a/promtest/test/promtest_gauge.h b/promtest/test/promtest_gauge.h index 1abcc46..b418ef7 100644 --- a/promtest/test/promtest_gauge.h +++ b/promtest/test/promtest_gauge.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,4 +26,4 @@ int promtest_gauge_teardown(void); void promtest_gauge(void); -#endif // PROMTEST_GAUGE_H \ No newline at end of file +#endif // PROMTEST_GAUGE_H diff --git a/promtest/test/promtest_helpers.c b/promtest/test/promtest_helpers.c index e27d7ca..d658d0f 100644 --- a/promtest/test/promtest_helpers.c +++ b/promtest/test/promtest_helpers.c @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,8 +24,7 @@ struct MHD_Daemon *promtest_daemon; promtest_popen_buf_t *promtest_popen_buf_new(FILE *f) { - promtest_popen_buf_t *self = - (promtest_popen_buf_t *)malloc(sizeof(promtest_popen_buf_t)); + promtest_popen_buf_t *self = (promtest_popen_buf_t *)malloc(sizeof(promtest_popen_buf_t)); self->buf = malloc(32); self->size = 32; self->allocated = 32; @@ -52,8 +51,7 @@ int promtest_popen_buf_destroy(promtest_popen_buf_t *self) { } int promtest_popen_buf_read(promtest_popen_buf_t *self) { - for (int current_char = fgetc(self->f), i = 0; current_char != EOF; - current_char = fgetc(self->f), i++) { + for (int current_char = fgetc(self->f), i = 0; current_char != EOF; current_char = fgetc(self->f), i++) { promtest_popen_buf_ensure_space(self); self->buf[i] = current_char; self->size++; @@ -62,4 +60,4 @@ int promtest_popen_buf_read(promtest_popen_buf_t *self) { self->buf[self->size] = '\0'; self->size++; return 0; -} \ No newline at end of file +} diff --git a/promtest/test/promtest_helpers.h b/promtest/test/promtest_helpers.h index b6cb2c3..93beb01 100644 --- a/promtest/test/promtest_helpers.h +++ b/promtest/test/promtest_helpers.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 DigitalOcean Inc. + * Copyright 2019-2020 DigitalOcean Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License.