1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
%global _empty_manifest_terminate_build 0
Name: python-graphyte
Version: 1.7.1
Release: 1
Summary: Python 3 compatible library to send data to a Graphite metrics server (Carbon)
License: MIT License
URL: https://github.com/benhoyt/graphyte
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/90/d8/516d885a705a341c6c681b8407350378f2b0f485056338166e4a108c8bec/graphyte-1.7.1.tar.gz
BuildArch: noarch
%description
graphyte is a small Python library that sends data to a Graphite metrics
server (Carbon). We wrote it because the existing `graphitesend`_ library
didn’t support Python 3, and it also required gevent for asyncronous use.
graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
standard library’s ``threading`` module for asynchronous use.
The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
a command prompt, activate your virtualenv if you’re using one, and type:
pip install graphyte
Using graphyte is simple – just call ``init()`` to initialize the default
sender and then ``send()`` to send a message. For example, to send
``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
synchronously:
import graphyte
graphyte.init('graphite.example.com', prefix='system.sync')
graphyte.send('foo.bar', 42)
If you want to send asynchronously on a background thread (for example, in a
web server context), just specify a send interval. For example, this will
setup a background thread to send every 10 seconds:
graphyte.init('graphite.example.com', prefix='system.async', interval=10)
graphyte.send('foo.bar', 42)
If you want to send tagged metrics, the usage is as follows:
graphite.send('foo.bar', 42, tags={'ding': 'dong'})
For more advanced usage, for example if you want to send to multiple servers
or if you want to subclass ``Sender``, you can instantiate instances of
``Sender`` directly. For example, to instantiate two senders sending to
different servers (one synchronous, one using a background thread with send
interval 10 seconds), use something like the following:
sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
sender1.send('foo.bar1', 42)
sender2.send('foo.bar2', 43)
If you want to send via UDP instead of TCP, just add ``protocol='udp'`` to
the ``init()`` or ``Sender()`` call.
Or, to customize how messages are logged or sent to the socket, subclass
``Sender`` and override ``send_message`` (or even ``send_socket`` if you
want to override logging and exception handling):
class CustomSender(graphyte.Sender):
def send_message(self, message):
print('Sending bytes in some custom way: {!r}'.format(message))
By default, exceptions that occur when sending a message are logged. If you
want to raise and propagate exceptions instead, instantiate ``Sender`` with
``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
``interval`` is specified.
Socket sending errors are logged using the Python logging system (using
logger name “graphyte”). If the sender is initialized with
``log_sends=True``, all sends are logged at the INFO level.
You can also use graphyte to send metrics directly from the command line:
python -m graphyte foo.bar 42
There are command line arguments to specify the server and port and other
configuration. Type ``python -m graphyte --help`` for help.
Read the code in `graphyte.py`_ for more details – it’s pretty small!
graphyte was written by `Ben Hoyt`_ and is licensed with a
permissive MIT license (see `LICENSE.txt`_).
**Related work:** `delphid`_ has a fork of graphyte which supports the statsd
protocol. See the changes on `delphid's branch`_.
%package -n python3-graphyte
Summary: Python 3 compatible library to send data to a Graphite metrics server (Carbon)
Provides: python-graphyte
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-graphyte
graphyte is a small Python library that sends data to a Graphite metrics
server (Carbon). We wrote it because the existing `graphitesend`_ library
didn’t support Python 3, and it also required gevent for asyncronous use.
graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
standard library’s ``threading`` module for asynchronous use.
The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
a command prompt, activate your virtualenv if you’re using one, and type:
pip install graphyte
Using graphyte is simple – just call ``init()`` to initialize the default
sender and then ``send()`` to send a message. For example, to send
``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
synchronously:
import graphyte
graphyte.init('graphite.example.com', prefix='system.sync')
graphyte.send('foo.bar', 42)
If you want to send asynchronously on a background thread (for example, in a
web server context), just specify a send interval. For example, this will
setup a background thread to send every 10 seconds:
graphyte.init('graphite.example.com', prefix='system.async', interval=10)
graphyte.send('foo.bar', 42)
If you want to send tagged metrics, the usage is as follows:
graphite.send('foo.bar', 42, tags={'ding': 'dong'})
For more advanced usage, for example if you want to send to multiple servers
or if you want to subclass ``Sender``, you can instantiate instances of
``Sender`` directly. For example, to instantiate two senders sending to
different servers (one synchronous, one using a background thread with send
interval 10 seconds), use something like the following:
sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
sender1.send('foo.bar1', 42)
sender2.send('foo.bar2', 43)
If you want to send via UDP instead of TCP, just add ``protocol='udp'`` to
the ``init()`` or ``Sender()`` call.
Or, to customize how messages are logged or sent to the socket, subclass
``Sender`` and override ``send_message`` (or even ``send_socket`` if you
want to override logging and exception handling):
class CustomSender(graphyte.Sender):
def send_message(self, message):
print('Sending bytes in some custom way: {!r}'.format(message))
By default, exceptions that occur when sending a message are logged. If you
want to raise and propagate exceptions instead, instantiate ``Sender`` with
``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
``interval`` is specified.
Socket sending errors are logged using the Python logging system (using
logger name “graphyte”). If the sender is initialized with
``log_sends=True``, all sends are logged at the INFO level.
You can also use graphyte to send metrics directly from the command line:
python -m graphyte foo.bar 42
There are command line arguments to specify the server and port and other
configuration. Type ``python -m graphyte --help`` for help.
Read the code in `graphyte.py`_ for more details – it’s pretty small!
graphyte was written by `Ben Hoyt`_ and is licensed with a
permissive MIT license (see `LICENSE.txt`_).
**Related work:** `delphid`_ has a fork of graphyte which supports the statsd
protocol. See the changes on `delphid's branch`_.
%package help
Summary: Development documents and examples for graphyte
Provides: python3-graphyte-doc
%description help
graphyte is a small Python library that sends data to a Graphite metrics
server (Carbon). We wrote it because the existing `graphitesend`_ library
didn’t support Python 3, and it also required gevent for asyncronous use.
graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
standard library’s ``threading`` module for asynchronous use.
The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
a command prompt, activate your virtualenv if you’re using one, and type:
pip install graphyte
Using graphyte is simple – just call ``init()`` to initialize the default
sender and then ``send()`` to send a message. For example, to send
``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
synchronously:
import graphyte
graphyte.init('graphite.example.com', prefix='system.sync')
graphyte.send('foo.bar', 42)
If you want to send asynchronously on a background thread (for example, in a
web server context), just specify a send interval. For example, this will
setup a background thread to send every 10 seconds:
graphyte.init('graphite.example.com', prefix='system.async', interval=10)
graphyte.send('foo.bar', 42)
If you want to send tagged metrics, the usage is as follows:
graphite.send('foo.bar', 42, tags={'ding': 'dong'})
For more advanced usage, for example if you want to send to multiple servers
or if you want to subclass ``Sender``, you can instantiate instances of
``Sender`` directly. For example, to instantiate two senders sending to
different servers (one synchronous, one using a background thread with send
interval 10 seconds), use something like the following:
sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
sender1.send('foo.bar1', 42)
sender2.send('foo.bar2', 43)
If you want to send via UDP instead of TCP, just add ``protocol='udp'`` to
the ``init()`` or ``Sender()`` call.
Or, to customize how messages are logged or sent to the socket, subclass
``Sender`` and override ``send_message`` (or even ``send_socket`` if you
want to override logging and exception handling):
class CustomSender(graphyte.Sender):
def send_message(self, message):
print('Sending bytes in some custom way: {!r}'.format(message))
By default, exceptions that occur when sending a message are logged. If you
want to raise and propagate exceptions instead, instantiate ``Sender`` with
``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
``interval`` is specified.
Socket sending errors are logged using the Python logging system (using
logger name “graphyte”). If the sender is initialized with
``log_sends=True``, all sends are logged at the INFO level.
You can also use graphyte to send metrics directly from the command line:
python -m graphyte foo.bar 42
There are command line arguments to specify the server and port and other
configuration. Type ``python -m graphyte --help`` for help.
Read the code in `graphyte.py`_ for more details – it’s pretty small!
graphyte was written by `Ben Hoyt`_ and is licensed with a
permissive MIT license (see `LICENSE.txt`_).
**Related work:** `delphid`_ has a fork of graphyte which supports the statsd
protocol. See the changes on `delphid's branch`_.
%prep
%autosetup -n graphyte-1.7.1
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-graphyte -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Sun Apr 23 2023 Python_Bot <Python_Bot@openeuler.org> - 1.7.1-1
- Package Spec generated
|
