This method tracks blasCalls
760773
@Deprecated
    public void processBlasCall(String blasOpName) {
        String key = "BLAS";
        invocationsCount.incrementAndGet();

        // using blas function opName as key
        opCounter.incrementCount(blasOpName);

        // all blas calls share the same key
        classCounter.incrementCount(key);

        updatePairs(blasOpName, key);

        prevOpMatching = "";
        lastZ = 0;
    }
1047129
function on(event, selector, callback) {
    const allowed = ['enter', 'leave'];

    if (!event) throw new Error('No event given. Choose either enter or leave');
    if (!selector) throw new Error('No selector to track');
    if (allowed.indexOf(event) < 0) throw new Error(`${event} event is not supported`);

    if (!{}.hasOwnProperty.call(this.trackedElements, selector)) {
        this.trackedElements[selector] = {};
    }

    this.trackedElements[selector].nodes = [];

    for (let i = 0, elems = document.querySelectorAll(selector); i < elems.length; i++) {
        const item = {
            isVisible: false,
            wasVisible: false,
            node: elems[i]
        };

        this.trackedElements[selector].nodes.push(item);
    }

    if (typeof callback === 'function') {
        if (!this.trackedElements[selector][event]) {
            this.trackedElements[selector][event] = {};
        }

        this.trackedElements[selector][event][(callback.name || 'anonymous')] = callback;
    }
}
1160593
def monitor(self, listener):
        
        for line in self._stream():
            self._record.append(line)
            if self.verbose:
                self.out.blather(line)
            if listener(line) is self.MONITOR_STOP:
                return
712463
private void trackFilters(final BundleContext bundleContext) {
		final ServiceTracker<Filter, FilterWebElement> filterTracker = FilterTracker
				.createTracker(extenderContext, bundleContext);

		filterTracker.open();
		trackers.add(0, filterTracker);

		// FIXME needed?
		final ServiceTracker<FilterMapping, FilterMappingWebElement> filterMappingTracker = FilterMappingTracker
				.createTracker(extenderContext, bundleContext);

		filterMappingTracker.open();
		trackers.add(0, filterMappingTracker);
	}
1177646
def method_missing(m, *args, &block)  
        if @tracker_names.include? m
          @tracker_blocks[m] = block
        else
          super(name, *args, &block)
        end
      end
48096
def track(self, message, name="Message"):
        
        if self.chatbase_token:
            asyncio.ensure_future(self._track(message, name))
213244
function bfs(img, startCoord, eventMap, blacklist) {
    var queue = _is('Array', startCoord) ? startCoord : [startCoord];

    if (_isImgLoaded(img)) {
        _bfs(_wrapByCanvas(img), queue, eventMap, blacklist);
    } else {
        img.addEventListener('load', function() {
            _bfs(_wrapByCanvas(img), queue, eventMap, blacklist);
        }, false);
    }
}
260320
function checksupercall() {
		keywords.every(function(keyword) {
			if (findbehind(keyword)) {
				supercall = true;
				methodname = true;
				buffer = buffer.substr(0, startindex(keyword));
				buffer += prototype;
				return false;
			}
			return true;
		});
	}
1272772
public void trackEvent(String argCategory, String argAction, String argLabel, Integer argValue) {
        AnalyticsRequestData data = new AnalyticsRequestData();
        data.setEventCategory(argCategory);
        data.setEventAction(argAction);
        data.setEventLabel(argLabel);
        data.setEventValue(argValue);

        makeCustomRequest(data);
    }
374884
def trace(self, context, obj):
		""""""
		
		root = obj
		
		if isroutine(obj):
			yield Crumb(self, root, endpoint=True, handler=obj, options=opts(obj))
			return
		
		for name, attr in getmembers(obj if isclass(obj) else obj.__class__):
			if name == '__getattr__':
				sig = signature(attr)
				path = '{' + list(sig.parameters.keys())[1] + '}'
				reta = sig.return_annotation
				
				if reta is not sig.empty:
					if callable(reta) and not isclass(reta):
						yield Crumb(self, root, path, endpoint=True, handler=reta, options=opts(reta))
					else:
						yield Crumb(self, root, path, handler=reta)
				
				else:
					yield Crumb(self, root, path, handler=attr)
				
				del sig, path, reta
				continue
			
			elif name == '__call__':
				yield Crumb(self, root, None, endpoint=True, handler=obj)
				continue
			
			if self.protect and name[0] == '_':
				continue
			
			yield Crumb(self, root, name,
					endpoint=callable(attr) and not isclass(attr), handler=attr, options=opts(attr))
782832
private void trackingStopMenuItemActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_trackingStopMenuItemActionPerformed
        if (trackingWorker != null) {
            trackingWorker.cancel();
        } else {
            assert(false);
        }
    }
166543
function clickJoinOrLeaveVideoChat(isStopByInitiator, isStopByBadNetwork) {
    if(!client){
      initialise();
    }

    var messageText,
        btnState;

    $('#videos div.row').empty();

    // Stop
    if (callIsInProgress) {
        $('#call_btn').prop('disabled', "disabled");

        stopAllICEFailedTimers();

        client.leave({
            success: function() {

                var next = function(){
                  client.destroySession({
                      success: function() {
                          clearEventsListeners();

                          $('.videoconf_ids').text(null);

                          if (isInitiator) {
                              if(isStopByBadNetwork){
                                notifyAboutCallState('dropCall');
                              }else{
                                notifyAboutCallState('stopCall');
                              }
                              messageText = 'Has finished video chat';
                              btnState = 'start';
                              isInitiator = false;

                              changeVideoChatStatus(currentDialog._id, false);
                          } else {
                              messageText = 'Has left video chat';
                              btnState = isStopByInitiator ? 'start' : 'join';
                          }

                          sendCallPresence(messageText);
                          updateVideoAndAudioChatButton(btnState);

                          // update UI
                          $("#video_chat_col").hide("slow", function() {
                              $("#chat_history_col").show("fast", function() {
                                  setTimeout(function() {
                                      $('#call_btn').prop('disabled', null);
                                  }, 1000);

                                  callIsInProgress = false;
                              });
                          });
                      },
                      error: function(error) {
                          console.warn("Error in 'destroySession': ", error);
                      }
                  });
                };

                client.detachVideoConferencingPlugin({
                    success: function() {
                        console.warn("Success detachVideoConferencingPlugin");
                        next();
                    },
                    error: function(error) {
                        console.warn("Error in 'detachVideoConferencingPlugin': ", error);
                        next();
                    }
                });

            }
        });


    // Start
    } else {
        if(!currentDialog){
          bootbox.alert("Please create a chat dialog first");
          return;
        }

        $('#call_btn').prop('disabled', "disabled");

        // Init Video engine
        //
        client.createSession({
            success: function() {

                initEventsListeners();

                // If this is Safari, let's avoid video
                if(adapter.browserDetails.browser === "safari") {
                    toastr.warning("Our video stream has been rejected because Safari does not support VP8 code. Viewers won't see us, only listen.");
                }

                client.attachVideoConferencingPlugin(false, null, {
                    success: function() {

                        actionsForTheInitiator();

                        $('.videoconf_ids').text("SID: " + client.getSessionId() + ". PID: " + client.getPluginId());

                        $("#chat_history_col").hide("slow", function() {
                            $("#video_chat_col").show("fast", function() {

                                // show local video feed
                                addFeedView(currentUser.id, true);

                                // join video chat
                                var roomIdToJoin = currentDialog._id;

                                client.join(roomIdToJoin, currentUser.id, isAudioCallOnly, {
                                    success: function() {
                                        console.log("JOINED " + client.currentDialogId + " dialog");

                                        if (isInitiator) {
                                            messageText = 'Started call';
                                            btnState = 'end';

                                            changeVideoChatStatus(currentDialog._id, true);
                                        } else {
                                            messageText = 'Joined call';
                                            btnState = 'leave';
                                        }

                                        sendCallPresence(messageText);
                                        updateVideoAndAudioChatButton(btnState);

                                        setTimeout(function() {
                                            $('#call_btn').prop('disabled', null);
                                        }, 1000);

                                        callIsInProgress = true;

                                        //
                                        // // TEMP
                                        // setTimeout(function() {
                                        //   clickJoinOrLeaveVideoChat(false, true);
                                        //
                                        //   bootbox.alert("TEST: The connectivity is gone because of heavy data loss. Please rejoin the call.");
                                        // }, 15000);
                                    },
                                    error: function(error) {
                                        bootbox.alert("Can't join video chat. Please check your Internet connection");
                                    }
                                });

                            });
                        });

                    },
                    error: function(error) {
                        console.error("Error in 'attachVideoConferencingPlugin': ", error);

                        // #define VIDEOROOM_ERROR_ID_EXISTS			436
                        // #define VIDEOROOM_ERROR_UNAUTHORIZED		433
                        // #define 'User ID xxx already exists'		400
                        //
                        if (error["error_code"] == 433 || error["error_code"] == 436 || error["error_code"] == 400) {
                            clickJoinOrLeaveVideoChat();
                        }

                        bootbox.alert("Error attaching plugin... " + (error["error"] || error));
                    },
                    webrtcState: function(on) {
                        console.info("LOCAL WebRTC PeerConnection is " + (on ? "up" : "down") + " now");

                        if(on){
                          QBVideoConferencingClient.listVideoinputDevices(function(videoinputDevices){
                            userVideoinputDevices = videoinputDevices;
                            readyLocalVideoUI(videoinputDevices);
                          });
                        }
                    },
                    consentDialog: function(on) {
                        console.info("Consent dialog should be " + (on ? "on" : "off") + " now");
                    },
                    mediaState: function(medium, on) {
                        console.info("LOCAL MediaState (own):  " + (on ? "started" : "stopped") + " receiving our " + medium);

                        // Trying to fix 'ICE failed' error.
                        // If it's happened - then close current session.
                        if(!on){
                          if(medium == "audio"){
                            runICEFailedTimer(medium);
                          }
                        }else{
                          if(medium == "audio"){
                            stopICEFailedTimer(medium);
                          }
                        }
                    },
                    slowLink: function(uplink, nacks) {
                      console.warn("LOCAL slowLink detected. uplink: " + uplink + ". nacks: " + nacks);
                      toastr.warning("slow link detected");
                    },
                    iceState: function(iceConnectionState){
                      console.warn("LOCAL iceState: " + iceConnectionState);

                      if(iceConnectionState == "disconnected" || iceConnectionState == "checking"){
                        playSoundOnNewMessage()

                        startSpiner("local");
                        hideLocalVideo();
                      }else if (iceConnectionState == "connected"){
                        playSoundOnNewMessage()

                        stopSpiner("local");
                        showLocalVideo();
                      }else if (iceConnectionState == "failed"){
                        playSoundOnNewMessage()

                        console.error("Local peer connection has failed because of ICE failed.");
                        console.info("Trying Local ICE restart...");

                        // perform ICE restart
                        //
                        client.iceRestart({
                          success: function() {
                            // console.info("iceRestart success");
                          },
                          error: function(error) {
                            console.warn("iceRestart error: " + JSON.stringify(error));
                          }
                        });
                      }
                    },
                    oncleanup: function() {

                    }
                });

            },

            error: function(error) {
                console.error("Error in 'createSession': ", error);

                $('#call_btn').prop('disabled', null);

                if(error == "Lost connection to the gateway (is it down?)"){

                }else if(error == "Error connecting to the Janus WebSockets server: Is the gateway down?"){
                  if (callIsInProgress) {
                      clickJoinOrLeaveVideoChat();
                  }
                  bootbox.alert("Lost connection to the server. Please check your Internet connection and restart the app.");
                }
            },

            destroyed: function() {
                console.info("Session is destroyed");
            },

            timeoutSessionCallback: function() {
                console.warn("timeoutSessionCallback CALL!!!!");
                bootbox.alert("Server session timeout (because of bad Internet connection). Please check your Internet connection and restart the app");
                clickJoinOrLeaveVideoChat(false, true);
            }
        });

    }
}
634003
function() {
		this.spiritualized = true;
		var list = this._readycallbacks;
		if (list) {
			while (list.length) {
				list.shift()();
			}
			this._readycallbacks = null;
		}
	}
90428
Map<String, List<String>> getBlackListedTrackers() {

    Map<String, List<String>> blackListedTrackers
        = new HashMap<String, List<String>>();

    for (Map.Entry<String,List<String>> e : trackerToFailuresMap.entrySet()) {
       if (e.getValue().size() >= maxTaskFailuresPerTracker) {
         blackListedTrackers.put(e.getKey(), e.getValue());
       }
    }
    return blackListedTrackers;
  }
690291
function track(property, thisArg){
    if(!(property in trackedProperties)){
      trackedProperties[property] = true;
      values[property] = model[property];
      Object.defineProperty(model, property, {
        get: function () { return values[property]; },
        set: function(newValue) {
          var oldValue = values[property];
          values[property] = newValue;
          getListeners(property).forEach(function(callback){
            callback.call(thisArg, newValue, oldValue);
          });
        }
      });
    }
  }
22977
def _batch_call_watchers(self_):
        
        while self_.self_or_cls.param._events:
            event_dict = OrderedDict([((event.name, event.what), event)
                                      for event in self_.self_or_cls.param._events])
            watchers = self_.self_or_cls.param._watchers[:]
            self_.self_or_cls.param._events = []
            self_.self_or_cls.param._watchers = []

            for watcher in watchers:
                events = [self_._update_event_type(watcher, event_dict[(name, watcher.what)],
                                                   self_.self_or_cls.param._TRIGGER)
                          for name in watcher.parameter_names
                          if (name, watcher.what) in event_dict]
                with batch_watch(self_.self_or_cls, run=False):
                    if watcher.mode == 'args':
                        watcher.fn(*events)
                    else:
                        watcher.fn(**{c.name:c.new for c in events})
248005
function(callback) {
    this._cacheBackboneTraces();
    for (var i=0; i < this._cachedTraces.length; ++i) {
      callback(this._cachedTraces[i]);
    }
  }