Graphite-Simple

 view release on metacpan or  search on metacpan

Simple.xs  view on Meta::CPAN

    memset(&self->sock_addr_unix, 0, sizeof(sockaddr_un));
    memset(&self->sock_addr_inet, 0, sizeof(sockaddr_in));
    apply_constructor_options_(self, opts);

    RETVAL = self;
OUTPUT:
    RETVAL


IV is_connected (GraphiteXS_Object *self)
PPCODE:
    mXPUSHi(self->is_connected ? 1 : 0);
    XSRETURN(1);


IV connect (GraphiteXS_Object *self)
PPCODE:
    connect_(self);
    mXPUSHi(self->is_connected ? 1 : 0);
    XSRETURN(1);


IV reconnect (GraphiteXS_Object *self)
PPCODE:
    disconnect_(self);
    connect_(self);
    mXPUSHi(self->is_connected ? 1 : 0);
    XSRETURN(1);


void disconnect (GraphiteXS_Object *self)
PPCODE:
    disconnect_(self);
    XSRETURN_EMPTY;


HV* get_bulk_metrics (GraphiteXS_Object *self)
CODE:
    //ST(0) = sv_mortalcopy((SV *) self->bulk_hv); // mXPUSHs((SV *) self->bulk_hv );
    //ST(0) = sv_2mortal(newRV_noinc( (SV *) self->bulk_hv ));
    //XSRETURN(1);
    RETVAL = self->bulk_hv;

Simple.xs  view on Meta::CPAN

HV* get_invalid_metrics (GraphiteXS_Object *self)
CODE:
    RETVAL = self->invalid_hv;
OUTPUT:
    RETVAL


SV* send_bulk (GraphiteXS_Object* self)
PPCODE:

    IV is_success = 1;

    if (self->is_connected) {

        SSize_t keys_cnt = hv_iterinit(self->bulk_hv);

        if (keys_cnt) {

            // writes results into self->bulk_hv

Simple.xs  view on Meta::CPAN

    }
    else
        warn("Client is not connected to server");

    clear_bulk_(self);
    mXPUSHi(move(is_success));
    XSRETURN(1);


SV* send_bulk_delegate (GraphiteXS_Object *self)
PPCODE:

    const char *sender = SvPVX(self->sender_name);

    if (!sender)
        croak("No sender was specified");

    calculate_result_metrics_(self);

    // see "man perlcall" for details

Simple.xs  view on Meta::CPAN

HV* get_average_counters (GraphiteXS_Object *self)
CODE:
    RETVAL = self->avg_hv;
OUTPUT:
    RETVAL


void clear_bulk (GraphiteXS_Object *self)
PPCODE:
    clear_bulk_(self);
    XSRETURN_EMPTY;


void incr_bulk (GraphiteXS_Object *self, SV* key, NV value = 1)
PPCODE:
    bool is_ok = false;
    if (key != &PL_sv_undef) {
        uint32_t key_type = SvTYPE(key);
        if (key_type == SVt_PVLV || key_type == SVt_PVMG) {
            // SVt_PVLV can be returned from substr
            // SVt_PVMG can be returned from RegExp
            STRLEN key_len;
            char *ch = SvPVx(move(key), key_len);
            key = newSVpv(move(ch), move(key_len));
        }

Simple.xs  view on Meta::CPAN

        }
    }

    if (!is_ok)
        croak("key must be a string");

    XSRETURN_EMPTY;


void append_bulk (GraphiteXS_Object *self, HV* hv, SV* prefix = &PL_sv_undef)
PPCODE:

    if (SvTIED_mg((SV *) hv, PERL_MAGIC_tied))
        croak("Tied hashes are not supported");

    bool use_prefix = false;

    if (prefix && prefix != &PL_sv_undef) {

        uint32_t type = SvTYPE(prefix);

Simple.xs  view on Meta::CPAN

        if (use_prefix)
            sv_setpv(key, ( sprefix + SvPVX(key) ).c_str());

        increment_metric_( self, move(key), move(SvNVx(value)) );
    }

    XSRETURN_EMPTY;


SV* is_valid_key (GraphiteXS_Object *self, SV* key)
PPCODE:
    bool is_valid = is_valid_key_(self, move(key));
    mXPUSHi( move(is_valid ? 1 : 0) );
    XSRETURN(1);


IV get_invalid_key_counter (GraphiteXS_Object *self)
PPCODE:
    mXPUSHi( self->invalid_key_counter );
    XSRETURN(1);


void check_and_bump_invalid_metric (GraphiteXS_Object *self, SV* key)
PPCODE:
    if ( SVt_NULL != SvTYPE(key) ) {
        uint32_t counter = move(self->invalid_key_counter);
        self->invalid_key_counter = 0;
        increment_hash_value_by( self->bulk_hv, move(key), move(counter) );
    }
    XSRETURN_EMPTY;


IV is_metric_blocked (GraphiteXS_Object *self, SV* key)
PPCODE:
    bool is_blocked = false;
    if ( is_valid_key_(self, key) )
        is_blocked = is_metric_blocked_(self, move(key));
    mXPUSHi( move(is_blocked ? 1 : 0) );
    XSRETURN(1);


void set_blocked_metrics_re (GraphiteXS_Object *self, SV* block_re = &PL_sv_undef)
PPCODE:
    set_blocked_metrics_re_(self, block_re);
    XSRETURN_EMPTY;


void DESTROY (...)
PPCODE:
    GraphiteXS_Object *self = (GraphiteXS_Object *) SvUV(SvRV(ST(0)));
    if (PL_dirty) // global destruction
        return;
    if (self->sender_name && SvREFCNT(self->sender_name)) // sv_clear
        SvREFCNT_dec_NN(self->sender_name);
    if (self->global_prefix && SvREFCNT(self->global_prefix)) // sv_clear
        SvREFCNT_dec_NN(self->global_prefix);
    if (self->hostname && SvREFCNT(self->hostname)) // sv_clear
        SvREFCNT_dec_NN(self->hostname);
    if (self->sock_path && SvREFCNT(self->sock_path)) // sv_clear